public static string LocalizedString(this DeviceConnectionStatus deviceConnectionStatus)
{
switch (deviceConnectionStatus)
{
case DeviceConnectionStatus.BluetoothError:
return(Translations.Language.Enum_DeviceConnectionStatus_BluetoothError);
case DeviceConnectionStatus.Connected:
return(Translations.Language.Enum_DeviceConnectionStatus_Connected);
case DeviceConnectionStatus.Disconnected:
return(Translations.Language.Enum_DeviceConnectionStatus_Disconnected);
case DeviceConnectionStatus.Disconnecting:
return(Translations.Language.Enum_DeviceConnectionStatus_Disconnecting);
case DeviceConnectionStatus.Failed: return(Translations.Language.Enum_DeviceConnectionStatus_Failed);
case DeviceConnectionStatus.Connecting:
return(Translations.Language.Enum_DeviceConnectionStatus_Connecting);
case DeviceConnectionStatus.USBError: return(Translations.Language.Enum_DeviceConnectionStatus_USBError);
case DeviceConnectionStatus.CommunicationError:
return(Translations.Language.Enum_DeviceConnectionStatus_CommunicationError);
case DeviceConnectionStatus.Unknown: return(Translations.Language.Enum_DeviceConnectionStatus_Unknown);
default: throw new ArgumentOutOfRangeException("deviceConnectionStatus");
}
}
/// <summary>
/// Sends the connection status back to the caller
/// </summary>
/// <param name="status">Status of the connect attempt.</param>
/// <param name="phase">Current phase of the connection attempt.</param>
/// <param name="message">Optional message describing the connection status.</param>
private void SendConnectionStatus(
DeviceConnectionStatus status,
DeviceConnectionPhase phase,
string message = "")
{
this.ConnectionStatus?.Invoke(this, new DeviceConnectionStatusEventArgs(status, phase, message));
}
private async Task <DeviceConnectionStatus> DeviceCheckConnectionRequest(HttpClient client, string publicKey)
{
HttpResponseMessage response = null;
Console.WriteLine("Checking for device connection request..");
response = await client.PostAsJsonAsync(apiBaseAddress + "DeviceCheckRemoteConnectionRequest", publicKey);
if (response.IsSuccessStatusCode)
{
bool authenticated = hmacResponseAuthenticator.IsResponseAuthenticated(response);
if (authenticated)
{
string responseString = await response.Content.ReadAsStringAsync();
DeviceConnectionStatus currentStatus = Newtonsoft.Json.JsonConvert.DeserializeObject <DeviceConnectionStatus>(responseString);
Console.WriteLine(responseString);
return(currentStatus);
}
}
else
{
await PrintFailMessage(response);
}
return(null);
}
private async Task <DeviceConnectionStatus> DeveloperCheckDeviceConnectionState(HttpClient client, string sshPublicKey)
{
HttpResponseMessage response = null;
DeveloperCheckDeviceConnectionArgs args = new DeveloperCheckDeviceConnectionArgs();
args.DeveloperSshPublicKey = sshPublicKey;
args.DeviceName = Configuration.Instance.TargetDevice;
response = await client.PostAsJsonAsync(apiBaseAddress + "DeveloperCheckDeviceConnection", args);
if (response.IsSuccessStatusCode)
{
bool authenticated = hmacAuthenticator.IsResponseAuthenticated(response);
if (authenticated)
{
string responseString = await response.Content.ReadAsStringAsync();
DeviceConnectionStatus currentStatus = Newtonsoft.Json.JsonConvert.DeserializeObject <DeviceConnectionStatus>(responseString);
logger.Debug(responseString);
return(currentStatus);
}
}
else
{
await PrintFailMessage(response);
}
return(null);
}
private IEnumerator CheckServiceConnection()
{
while (true)
{
ServiceConnectionStatus status = _plugin.TestServiceConnection();
if (status != _ServiceConnectionStatus)
{
_ServiceConnectionStatus = ChangeServiceConnectionStatus(status);
}
if (status == ServiceConnectionStatus.Connected)
{
var suitConnection = _plugin.TestDeviceConnection();
if (suitConnection != _DeviceConnectionStatus)
{
_DeviceConnectionStatus = ChangeDeviceConnectionStatus(suitConnection);
}
}
else
{
if (_DeviceConnectionStatus != DeviceConnectionStatus.Disconnected)
{
_DeviceConnectionStatus = ChangeDeviceConnectionStatus(DeviceConnectionStatus.Disconnected);
}
}
yield return(new WaitForSeconds(0.5f));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceConnectionStatusEventArgs"/> class.
/// </summary>
/// <param name="status">Status of the connection</param>
/// <param name="phase">Phase of the connection</param>
/// <param name="message">Optional message describing our connection/phase</param>
internal DeviceConnectionStatusEventArgs(
DeviceConnectionStatus status,
DeviceConnectionPhase phase,
string message = "")
{
this.Status = status;
this.Phase = phase;
this.Message = message;
}
internal DeviceConnectionEventArgs(uint id, byte interfaceIndex, BaseDevice.DeviceType type, ushort vendorId, ushort productId, byte portNumber, DeviceConnectionStatus deviceStatus)
{
this.id = id;
this.interfaceIndex = interfaceIndex;
this.type = type;
this.vendorId = vendorId;
this.productId = productId;
this.portNumber = portNumber;
this.deviceStatus = deviceStatus;
}
private DeviceConnectionStatus ChangeDeviceConnectionStatus(DeviceConnectionStatus newStatus)
{
if (newStatus == DeviceConnectionStatus.Connected)
{
OnSuitConnected(new SuitConnectionArgs());
}
else
{
OnSuitDisconnected(new SuitConnectionArgs());
}
return(newStatus);
}
public IActionResult DeviceCheckRemoteConnectionRequest([FromBody] string devicePublicKey)
{
#warning to move in infrastructure module
string deviceIdentity = (string)HttpContext.Items["ClientName"];
Console.WriteLine("Device identity is: " + deviceIdentity);
var deviceConnectionRequest = clientConnections.GetByClientName(deviceIdentity);
bool isDeviceConnectionRequested = deviceConnectionRequest != null;
if (isDeviceConnectionRequested)
{
// Verifica dello stato della connessione, se è già attiva non devo fare nulla
var deviceConnection = this.clientConnections.CheckDeviceConnection(deviceIdentity);
Core.Entities.DeviceConnectionStatus connectionStatus = ClientConnectionMapper.Mapper.Map <Core.Entities.DeviceConnectionStatus>(deviceConnection);
// Altrimenti devo fare in modo che venga attivata la nuova connessione
if (connectionStatus.State != EnumClientConnectionState.Connected)
{
this.ssh.SaveClientKeys(connectionStatus.SshForwarding, "device_" + deviceIdentity, devicePublicKey);
// Generating Ssh connection details
Core.Entities.DeviceConnectionStatus connectionDetails = GenerateSshConnectionDetails();
// Inserting connection details to database
this.clientConnections.SetDeviceConnectionDetails(deviceIdentity, connectionDetails);
return(Ok(connectionDetails));
}
// in questo caso torna connected (quello che ha detto il db)
return(Ok(connectionStatus));
}
else if (!isDeviceConnectionRequested)
{
DeviceConnectionStatus connectionStatus = new DeviceConnectionStatus()
{
State = EnumClientConnectionState.NotRequest
};
return(Ok(connectionStatus));
}
else
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Database error"));
}
}
public async Task Run()
{
while (true)
{
DeviceConnectionStatus connectionDetails = await http.CheckRemoteConnectionRequest(ssh.PublicKey);
if (connectionDetails != null)
{
// Reset the connection if the client is connected with the wrong port (old connections)
if (ssh.ConnectionState == EnumSshConnectionState.Open && ssh.CurrentForwardingPort != connectionDetails.SshForwarding)
{
ssh.CloseSshConnection("wrong port and is open");
}
if ((connectionDetails.State == EnumClientConnectionState.Ready) && ssh.ConnectionState != EnumSshConnectionState.Open)
{
// Attesa di 2 secondi per fare in modo che OpenSSH acquisisca i certificati che abbiamo appena caricato
System.Threading.Thread.Sleep(5000);
ssh.OpenSshConnection(connectionDetails);
ssh.EnableRemoteForwarding(connectionDetails);
}
else if ((connectionDetails.State == EnumClientConnectionState.NotRequest) && (ssh.ConnectionState == EnumSshConnectionState.Open))
{
ssh.CloseSshConnection("Not request and is open");
}
}
else
{
ssh.CloseSshConnection("no connection details");
}
// Connection status is beign constantly setted beacuse the server constantly check the last timestamp
// If the client goes offline, the server will mark the device as not connected automatically
if (ssh.ConnectionState == EnumSshConnectionState.Open)
{
await http.SetActiveDeviceConnection();
}
else if (connectionDetails != null && (connectionDetails.State != EnumClientConnectionState.NotRequest))
{
await http.SetClosedSshConnectionState();
}
System.Threading.Thread.Sleep(5000);
}
}
public async Task Run()
{
while (true)
{
// Insert connection request to the target device
await http.InsertConnectionRequest();
// Check device connection state to the ssh server
DeviceConnectionStatus deviceConnectionDetails = await http.CheckDeviceConnectionState(ssh.PublicKey);
if (deviceConnectionDetails != null)
{
// Reset the connection if the client is connected with the wrong port (old connections)
if (ssh.ConnectionState == EnumSshConnectionState.Open && ssh.CurrentForwardingPort != deviceConnectionDetails.SshForwarding)
{
ssh.CloseSshConnection("wrong port");
}
if (deviceConnectionDetails.State != EnumClientConnectionState.Connected)
{
logger.Output("Waiting for device connection..");
waiting = true;
}
else
{
if (ssh.ConnectionState != EnumSshConnectionState.Open)
{
logger.Debug("Device has been connected, connecting developer to the ssh server..");
ssh.OpenSshConnection(deviceConnectionDetails);
ssh.EnableLocalForwarding(deviceConnectionDetails);
logger.Output($"Developer SSH connection created: Device ssh server exposed on port {deviceConnectionDetails.SshForwarding})");
waiting = false;
}
else if (waiting)
{
logger.Output($"Developer SSH connection re-established: Device ssh server exposed on port {deviceConnectionDetails.SshForwarding})");
waiting = false;
}
}
}
System.Threading.Thread.Sleep(5000);
}
}
static void Main()
{
// DeviceConnectionStatus ist ohne [Flags] definiert. Eine Variable diesen
// Typs hat also immer nur einen der definierten Werte.
DeviceConnectionStatus connectionStatus = DeviceConnectionStatus.Available;
Console.WriteLine("Aktueller Verbindungsstatus: {0}", connectionStatus);
// Du kannst einer Enum auch einen Wert zuweisen der nicht für sie definiert
// ist. Dann bekommst du aber auch keine passende Beschreibung.
// Du musst auch schon einen richtigen Cast anwenden, damit der Compiler nicht
// meckert.
connectionStatus = (DeviceConnectionStatus)3;
Console.WriteLine("Aktueller Verbindungsstatus ohne gültige Beschreibung: {0}", connectionStatus);
DeviceErrorStatus error = DeviceErrorStatus.HardwareError
| DeviceErrorStatus.Hardware_CommunicationError
| DeviceErrorStatus.WatchdogError;
Console.WriteLine("Ist das Flag HardwareError gesetzt? {0}", error.HasFlag(DeviceErrorStatus.HardwareError));
Console.WriteLine("Ist das Flag SoftwareError gesetzt? {0}", error.HasFlag(DeviceErrorStatus.SoftwareError));
}
public async Task <DeviceConnectionStatus> CheckDeviceConnectionState(string sshPublicKey)
{
DeviceConnectionStatus state = await DeveloperCheckDeviceConnectionState(client, sshPublicKey);
return(state);
}
public Task <DeviceConnectionStatus> TestDevice()
{
lock (this._locker)
{
this.CloseIfOpen();
try
{
this._serialDevice.Open();
this._serialDevice.OnReceivedData = (Func <byte[], bool>)null;
DeviceConnectionStatus result = DeviceConnectionStatus.InitializationError;
this.GetReadDataSync("3p=", (Action <string>)(res =>
{
if (!res.ContainsIgnoreCase("OK"))
{
result = DeviceConnectionStatus.InitializationError;
}
else
{
this.ForceGoodReadTone();
result = DeviceConnectionStatus.Enabled;
}
}));
StaticTimer.Wait((Func <bool>)(() => result == DeviceConnectionStatus.InitializationError), 2);
if (result == DeviceConnectionStatus.InitializationError)
{
return(Task.FromResult <DeviceConnectionStatus>(result));
}
result = DeviceConnectionStatus.InitializationError;
this.GetReadDataSync("14", (Action <string>)(res =>
{
if (!res.StartsWith("S14"))
{
result = DeviceConnectionStatus.InitializationError;
}
else
{
res = res.Substring(3);
if (!res.StartsWith("3") && !res.StartsWith("5"))
{
result = DeviceConnectionStatus.InitializationError;
}
else
{
result = DeviceConnectionStatus.Enabled;
}
}
}));
StaticTimer.Wait((Func <bool>)(() => result == DeviceConnectionStatus.InitializationError), 2);
return(Task.FromResult <DeviceConnectionStatus>(result));
}
catch (Exception ex)
{
ILogger <Magellan9300S> logger = this._logger;
if (logger != null)
{
logger.LogError(ex, ex.Message);
}
if (ex.Message.ContainsIgnoreCase("port"))
{
Action <DeviceLog> onDeviceWarning = this.OnDeviceWarning;
if (onDeviceWarning != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.Critical;
barcodeScannerLog.Message = "Device not connected";
onDeviceWarning((DeviceLog)barcodeScannerLog);
}
return(Task.FromResult <DeviceConnectionStatus>(DeviceConnectionStatus.NotConnected));
}
Action <DeviceLog> onDeviceWarning1 = this.OnDeviceWarning;
if (onDeviceWarning1 != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.Critical;
barcodeScannerLog.Message = "Initialization error";
onDeviceWarning1((DeviceLog)barcodeScannerLog);
}
return(Task.FromResult <DeviceConnectionStatus>(DeviceConnectionStatus.InitializationError));
}
finally
{
this._serialDevice.OnReceivedData = new Func <byte[], bool>(this.OnDataReceived);
}
}
}
public DeviceConnectionStatus Init()
{
lock (this._locker)
{
try
{
this._tmpStr = string.Empty;
if (this._currentStatus == DeviceConnectionStatus.Enabled)
{
return(DeviceConnectionStatus.Enabled);
}
Action <DeviceLog> onDeviceWarning1 = this.OnDeviceWarning;
if (onDeviceWarning1 != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.All;
barcodeScannerLog.Message = "[Magellan9300S] - Start Initialization";
onDeviceWarning1((DeviceLog)barcodeScannerLog);
}
this.CloseIfOpen();
this._serialDevice.OnReceivedData = (Func <byte[], bool>)null;
this._serialDevice.Open();
this._serialDevice.Write(this.GetCommand("01"));
this._serialDevice.Write(this.GetCommand("339"));
byte[] buffer = new byte[this._serialDevice.ReadBufferSize];
this._serialDevice.Read(buffer, 0, buffer.Length);
this._serialDevice.DiscardInBuffer();
this._serialDevice.DiscardOutBuffer();
this._serialDevice.Write(this.GetCommand("3p="));
Action <DeviceLog> onDeviceWarning2 = this.OnDeviceWarning;
if (onDeviceWarning2 != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.All;
barcodeScannerLog.Message = "[Magellan9300S] - Get info about scanner";
onDeviceWarning2((DeviceLog)barcodeScannerLog);
}
for (int index = 0; this._serialDevice.ReadBufferSize < 1 && index < 10; ++index)
{
Thread.Sleep(100);
}
byte[] numArray = new byte[this._serialDevice.ReadBufferSize];
this._serialDevice.Read(numArray, 0, numArray.Length);
string str = Encoding.ASCII.GetString(numArray);
if (_logger != null)
{
_logger.LogDebug("[Magellan9300S] - Initialization message - " + str);
}
bool flag = str.ContainsIgnoreCase("OK");
Action <DeviceLog> onDeviceWarning3 = this.OnDeviceWarning;
if (onDeviceWarning3 != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.All;
barcodeScannerLog.Message = string.Format("[Magellan9300S] - Initialization result {0}", (object)flag);
onDeviceWarning3((DeviceLog)barcodeScannerLog);
}
this._currentStatus = flag ? DeviceConnectionStatus.Enabled : DeviceConnectionStatus.InitializationError;
return(this._currentStatus);
}
catch (Exception ex)
{
ILogger <Magellan9300S> logger = this._logger;
if (logger != null)
{
logger.LogError(ex, ex.Message);
}
if (ex.Message.ContainsIgnoreCase("port"))
{
Action <DeviceLog> onDeviceWarning = this.OnDeviceWarning;
if (onDeviceWarning != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.Critical;
barcodeScannerLog.Message = "Device not connected";
onDeviceWarning((DeviceLog)barcodeScannerLog);
}
return(DeviceConnectionStatus.NotConnected);
}
Action <DeviceLog> onDeviceWarning1 = this.OnDeviceWarning;
if (onDeviceWarning1 != null)
{
BarcodeScannerLog barcodeScannerLog = new BarcodeScannerLog();
barcodeScannerLog.Category = TerminalLogCategory.Critical;
barcodeScannerLog.Message = "Initialization error";
onDeviceWarning1((DeviceLog)barcodeScannerLog);
}
return(DeviceConnectionStatus.InitializationError);
}
finally
{
this._serialDevice.OnReceivedData = new Func <byte[], bool>(this.OnDataReceived);
}
}
}
public async Task <DeviceConnectionStatus> CheckRemoteConnectionRequest(string publicKey)
{
DeviceConnectionStatus state = await DeviceCheckConnectionRequest(client, publicKey);
return(state);
}
/// <summary>
/// Performs the action of the reestablish connection command
/// </summary>
/// <returns>A task capturing the continuation of the asynchronous action to reestablish the connection</returns>
private async Task ExecuteReestablishConnectionAsync()
{
this.OutputDiagnosticString("ExecuteReestablishConnectionAsync\n");
int numTries = 1;
DeviceConnectionStatus finalConnectionStatus = DeviceConnectionStatus.None;
DeviceConnectionStatusEventHandler handler = (DevicePortal sender, DeviceConnectionStatusEventArgs args) =>
{
this.OutputDiagnosticString("Connection status update: Status: {0}, Phase: {1}\n", args.Status, args.Phase);
if (args.Status == DeviceConnectionStatus.Connected)
{
this.OutputDiagnosticString("Connection succeeded after {0} tries.\n", numTries);
this.ConnectionStatus = DeviceConnectionStatus.Connected;
}
else if (args.Status == DeviceConnectionStatus.Failed)
{
this.OutputDiagnosticString("Connection failed after {0} tries.\n", numTries);
this.OutputDiagnosticString("HTTP Status: {0}\n", this.Portal.ConnectionHttpStatusCode);
this.OutputDiagnosticString("Failure description: {0}\n", args.Message);
}
finalConnectionStatus = args.Status;
};
this.Portal.ConnectionStatus += handler;
this.Ready = false;
try
{
do
{
await this.Portal.ConnectAsync();
if (this.Portal.ConnectionHttpStatusCode == HttpStatusCode.Unauthorized)
{
// Don't try to reconnect when there is an authentication failure
break;
}
else if (this.Portal.ConnectionHttpStatusCode != HttpStatusCode.OK && numTries <= this.ConnectionRetryAttempts)
{
await Task.Delay(1000 * 5);
}
++numTries;
}while (this.Portal.ConnectionHttpStatusCode != HttpStatusCode.OK && numTries <= this.ConnectionRetryAttempts);
if (this.Portal.ConnectionHttpStatusCode != HttpStatusCode.OK)
{
throw new Exception(string.Format("Unable to connect after {0} tries.", numTries - 1));
}
this.OnPropertyChanged("Address");
this.OnPropertyChanged("DeviceFamily");
this.OnPropertyChanged("OperatingSystemVersion");
this.OnPropertyChanged("Platform");
this.OnPropertyChanged("PlatformName");
}
catch (Exception exn)
{
this.ReportException("ReestablishConnection", exn);
}
this.Portal.ConnectionStatus -= handler;
this.Ready = true;
this.ConnectionStatus = finalConnectionStatus;
}
/// <summary>
/// Gets a composite key concatenating the values.
/// </summary>
/// <param name="httpStatusCode">The 3 digit Code denoting the Notification Response Status of the web call.</param>
/// <param name="pushNotificationStatus">The status of the notification received by the Microsoft Push Notification Service.</param>
/// <param name="deviceConnectionStatus">The connection status of the device.</param>
/// <param name="subscriptionStatus">The subscription status of the device.</param>
/// <returns>The resource key.</returns>
private static string GetKey(HttpStatusCode httpStatusCode, PushNotificationStatus pushNotificationStatus, DeviceConnectionStatus deviceConnectionStatus, SubscriptionStatus subscriptionStatus)
{
var key = String.Format(CultureInfo.InvariantCulture, "ResponseComments_{0}_{1}_{2}_{3}", httpStatusCode, pushNotificationStatus, deviceConnectionStatus, subscriptionStatus);
return(key);
}
private void ResponseComments_Test(HttpStatusCode httpStatusCode, PushNotificationStatus pushNotificationStatus, DeviceConnectionStatus deviceConnectionStatus, SubscriptionStatus subscriptionStatus, string value)
{
var result = new PushNotificationSendResult()
{
HttpStatusCode = httpStatusCode,
PushNotificationStatus = pushNotificationStatus,
DeviceConnectionStatus = deviceConnectionStatus,
PushNotificationSubscriptionStatus = subscriptionStatus,
};
Assert.AreEqual(result.Comments, value);
}
private void ResponseComments_Test(HttpStatusCode httpStatusCode, PushNotificationStatus pushNotificationStatus, DeviceConnectionStatus deviceConnectionStatus, SubscriptionStatus subscriptionStatus, string value)
{
var result = new PushNotificationSendResult()
{
HttpStatusCode = httpStatusCode,
PushNotificationStatus = pushNotificationStatus,
DeviceConnectionStatus = deviceConnectionStatus,
PushNotificationSubscriptionStatus = subscriptionStatus,
};
Assert.AreEqual(result.Comments, value);
}
/// <summary>
/// Gets a value indicating the possible set of reasons for the current response (Http Status + Notification Status + Device Connection Status + Subscription Status)/
/// This message may also suggest the next steps in many cases.
/// </summary>
/// <param name="httpStatusCode">The 3 digit Code denoting the Notification Response Status of the web call.</param>
/// <param name="pushNotificationStatus">The status of the notification received by the Microsoft Push Notification Service.</param>
/// <param name="deviceConnectionStatus">The connection status of the device.</param>
/// <param name="subscriptionStatus">The subscription status of the device.</param>
/// <returns>The suggestion as a message.</returns>
public static string GetComments(HttpStatusCode httpStatusCode, PushNotificationStatus pushNotificationStatus, DeviceConnectionStatus deviceConnectionStatus, SubscriptionStatus subscriptionStatus)
{
var message = String.Empty;
var key = Extensions.GetKey(httpStatusCode, pushNotificationStatus, deviceConnectionStatus, subscriptionStatus);
if (Extensions.pushNotificationServiceResponseComments.ContainsKey(key))
{
message = Extensions.pushNotificationServiceResponseComments[key];
}
return(message);
}
