public VehicleDataPacket Read()
        {
            ValueSet valuesToSend = new ValueSet();

            valuesToSend.Add("ADDRESS", (int)_simulatedDevice);
            valuesToSend.Add("REQUEST", "");

            ValueSet dataReceived = Task.Run(() => _simulatorCommunication.RequestDataAsync(valuesToSend)).GetAwaiter().GetResult(); //TODO: (ref. issue #4) This is a temporary hack that blocks the async method. WARNING MAY CAUSE ISSUES!. See if Read() can be rewritten to be async.  See Figure 7 "The Thread Pool Hack" on https://msdn.microsoft.com/en-us/magazine/mt238404.aspx

            NewDataReceived?.Invoke(this, EventArgs.Empty);

            return(ConvertData(dataReceived));
        }
Beispiel #2
0
        private void ReadCallback(IAsyncResult ar)
        {
            //get the client from the asynchronous state object
            TConnection C = null;

            try
            {
                C = AllConnections[(string)ar.AsyncState];
            }
            catch
            {
                ReportError?.Invoke("ReadCallback received from a client that is no longer in the database", "");
                return;
            }

            int bytesread = 0;

            try
            {
                bytesread = C.ConnectionSocket.EndReceive(ar); //acknowledge the data receipt
            }
            catch
            {
                ReportError?.Invoke("EndReceive failed during ReadCallback", C.Address);
            }
            if (bytesread > 0)
            {
                C.ConnStats.LastComm.Restart();
                C.ConnStats.Receivedpackets++;
                //call external function to process the data
                NewDataReceived?.Invoke(C.Address, C.IncomingData, bytesread);
                C.NrReceivedBytes = bytesread;
                C.DataReceived    = true;

                //call the data processing method of the connection itself
                C.ProcessData();
                C.ProcessDataAction?.Invoke();

                //set the socket back to listening mode
                try
                {
                    C.ConnectionSocket.BeginReceive(C.IncomingData, 0, C.IncomingData.Length, 0, new AsyncCallback(ReadCallback), C.Address);
                }
                catch
                {
                    ReportError?.Invoke("BeginReceive failed during ReadCallback", C.Address);
                }
            }
        }
        /// <summary>
        /// Init driver communication - means autorefresh of the messages
        /// </summary>
        /// <param name="nft"></param>
        /// <returns></returns>
        public override async Task Init(INFT nft)
        {
            CancelToken = CancelTokenSource.Token;

            _ = Task.Run(async() =>
            {
                IsRunning = true;

                var quit = false;
                while (!quit)
                {
                    if (CancelToken.IsCancellationRequested)
                    {
                        quit = true;
                    }

                    try
                    {
                        var res = await RequestNewMessageFromAPI();
                        if (res.Item1 && !string.IsNullOrEmpty(res.Item2.id))
                        {
                            if (res.Item2.id != lastmessageid)
                            {
                                NewDataReceived?.Invoke(this, JsonConvert.SerializeObject(res.Item2));
                                lastmessageid = res.Item2.id;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Cannot obtain new message from the HARDWARIO Cloud API. " + ex.Message);
                    }
                    await Task.Delay(CommonConnParams.CommonRefreshInterval);
                }
            }, CancelToken);

            IsRunning = false;
        }
Beispiel #4
0
 internal void OnNewDataReceived()
 {
     NewDataReceived?.Invoke();
 }
        private BluetoothImpl()
        {
            try
            {
                if (PlatformUtils.IsWindows && SettingsProvider.Instance.UseBluetoothWinRT &&
                    PlatformUtils.IsWindowsContractsSdkSupported)
                {
                    Log.Debug("BluetoothImpl: Using WinRT.BluetoothService");
                    _backend = new Bluetooth.WindowsRT.BluetoothService();
                }
#if WindowsNoARM
                else if (PlatformUtils.IsWindows)
                {
                    Log.Debug("BluetoothImpl: Using Windows.BluetoothService");
                    _backend = new Bluetooth.Windows.BluetoothService();
                }
#else
                else if (PlatformUtils.IsWindows && PlatformUtils.IsWindowsContractsSdkSupported)
                {
                    Log.Debug("BluetoothImpl: Using WinRT.BluetoothService (ARM)");
                    _backend = new Bluetooth.WindowsRT.BluetoothService();
                }
#endif
                else if (PlatformUtils.IsLinux)
                {
                    Log.Debug("BluetoothImpl: Using Linux.BluetoothService");
                    _backend = new Bluetooth.Linux.BluetoothService();
                }
                else
                {
                    Log.Warning("BluetoothImpl: Using Dummy.BluetoothService");
                    _backend = new Dummy.BluetoothService();
                }
            }
            catch (PlatformNotSupportedException)
            {
                Log.Error("BluetoothImpl: Critical error while preparing bluetooth backend");
                Log.Error("BluetoothImpl: Backend swapped out with non-functional dummy object in order to prevent crash");
                _backend = new Dummy.BluetoothService();
            }

            _cancelSource = new CancellationTokenSource();
            _loop         = Task.Run(DataConsumerLoop, _cancelSource.Token);

            _backend.Connecting          += (sender, args) => Connecting?.Invoke(this, EventArgs.Empty);
            _backend.NewDataAvailable    += OnNewDataAvailable;
            _backend.NewDataAvailable    += (sender, bytes) => NewDataReceived?.Invoke(this, bytes);
            _backend.BluetoothErrorAsync += (sender, exception) => OnBluetoothError(exception);

            _backend.RfcommConnected += (sender, args) => Task.Run(async() =>
                                                                   await Task.Delay(150).ContinueWith((_) =>
            {
                if (RegisteredDeviceValid)
                {
                    Connected?.Invoke(this, EventArgs.Empty);
                }
                else
                {
                    Log.Error("BluetoothImpl: Suppressing Connected event, device not properly registered");
                }
            }));

            _backend.Disconnected += (sender, reason) =>
            {
                if (!SuppressDisconnectionEvents)
                {
                    Disconnected?.Invoke(this, reason);
                }
            };

            MessageReceived += SPPMessageHandler.Instance.MessageReceiver;
        }
Beispiel #6
0
        public void startReaderTask()
        {
            if (state != ConnectionState.CONNECTED)
            {
                throw new InvalidOperationException("[TCPConnection2]: Unable to start reader task! ConnectionState != CONNECTED - state = " + state);
            }

            // Ensure no other reader task is running:
            if (readingCTS != null && !readingCTS.IsCancellationRequested)
            {
                readingCTS.Cancel();
            }

            readingCTS = new CancellationTokenSource();

            try
            {
                Task.Run(async() =>
                {
                    TCPReadResult readResult   = null;
                    int lastReadingFailedCount = 0;
                    int errorCount             = 0;
                    DateTime lastReadingFailed = DateTime.MinValue;

                    while (state == ConnectionState.CONNECTED && errorCount < 3)
                    {
                        try
                        {
                            readResult = await readAsync();
                            // Check if reading failed:
                            switch (readResult.STATE)
                            {
                            case TCPReadState.SUCCESS:
                                lastReadingFailedCount = 0;
                                errorCount             = 0;
                                Logger.Debug("[TCPConnection2]: Received from (" + account.serverAddress + "):" + readResult.DATA);

                                // Trigger the NewDataReceived event:
                                NewDataReceived?.Invoke(this, new NewDataReceivedEventArgs(readResult.DATA));
                                break;

                            case TCPReadState.FAILURE:
                                if (lastReadingFailedCount++ <= 0)
                                {
                                    lastReadingFailed = DateTime.Now;
                                }

                                // Read 5 empty or null strings in an interval lower than 1 second:
                                double c = DateTime.Now.Subtract(lastReadingFailed).TotalSeconds;
                                if (lastReadingFailedCount > 5 && c < 1)
                                {
                                    lastConnectionError = new ConnectionError(ConnectionErrorCode.READING_LOOP);
                                    errorCount          = int.MaxValue;
                                    continue;
                                }
                                break;

                            case TCPReadState.END_OF_STREAM:
                                Logger.Info("Socket closed because received 0-length message from: " + account.serverAddress);
                                disconnect();
                                break;
                            }
                        }
                        catch (OperationCanceledException)
                        {
                            lastConnectionError = new ConnectionError(ConnectionErrorCode.READING_CANCELED);
                            errorCount++;
                        }
                        catch (Exception e)
                        {
                            SocketErrorStatus status = SocketErrorStatus.Unknown;
                            if (e is AggregateException aggregateException && aggregateException.InnerException != null)
                            {
                                status = SocketError.GetStatus(e.InnerException.HResult);
                            }
                            else
                            {
                                Exception baseException = e.GetBaseException();
                                if (baseException != null)
                                {
                                    status = SocketError.GetStatus(e.GetBaseException().HResult);
                                }
                                else
                                {
                                    status = SocketError.GetStatus(e.HResult);
                                }
                            }

                            lastConnectionError = new ConnectionError(status, e.Message);
                            switch (status)
                            {
                            // Some kind of connection lost:
                            case SocketErrorStatus.ConnectionTimedOut:
                            case SocketErrorStatus.ConnectionRefused:
                            case SocketErrorStatus.NetworkDroppedConnectionOnReset:
                            case SocketErrorStatus.SoftwareCausedConnectionAbort:
                            case SocketErrorStatus.ConnectionResetByPeer:
                                errorCount = int.MaxValue;
                                break;

                            default:
                                errorCount++;
                                break;
                            }
                        }