private Task _ReadInputStreamTaskAsync() { return(Task.Run(() => { var inputStream = RfcommConnection.InputStream; bool disconnected = false; while (true) { byte[] buffer = new byte[255]; var readSize = inputStream.Read(buffer, 0, buffer.Length); if (readSize == 0) { disconnected = true; break; } var readBytes = new byte[readSize]; Array.Copy(buffer, 0, readBytes, 0, readSize); var msg = new RXReceiveMessage { RXConnection = this, Bytes = readBytes }; OnReceived?.Invoke(this, msg); } if (disconnected) { RfcommConnection.Dispose(); ConnectionState = RXConnectionState.Destoryed; OnConnectionStateChanged?.Invoke(this, ConnectionState); } })); }
public async Task StartAsync() { await HandleCommunicationAsync(); OnConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(ConnectionState.Closed)); OnClosed?.Invoke(this, null); }
public void ConnectionStateChangeCallback(string connectionId, string state) { if (Enum.TryParse <PeerConnectionState>(state, true, out var connectionState)) { OnConnectionStateChanged?.Invoke(connectionId, connectionState); } }
public async Task HandleCommunicationAsync() { while (IsConnected) { if (!client.Connected) { Log.Instance?.Info("No information from server... Will try to reconnect."); Disconnect(); break; } try { await UpdateAsync(); } catch { Disconnect(); } OnConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(ConnectionState.Updated)); Thread.Sleep(updateIntervalInMs); } await TryReconnect(); }
protected virtual void DismissCurrentConnection() { if (_connection == null) { return; } OnConnectionStateChanged?.Invoke(new StateChange(_connection.State, ConnectionState.Disconnected)); _connection.StateChanged -= OnConnectionStateChangedHandler; _connection.Reconnected -= OnReconnectedHandler; var connectionToDispose = _connection; _connection = null; // connection disposing can block the UI thread for about 20 seconds // this doesn´t always happen but just in case we run it on a new thread Task.Run(() => { try { connectionToDispose.Dispose(); } catch (Exception ex) { _tracer?.WriteLine($"[{_className}] Connection could not be disposed: {ex.Message}"); } }); }
protected override void OnResume() { CurrentActivity = this; if (string.IsNullOrEmpty(ActivityKey)) { ActivityKey = NextPageKey; NextPageKey = null; } // Gestion du retour en arrière jusqu'à une interface donnée if (_activityKeyToGoBackTo != string.Empty && _activityKeyToGoBackTo != ActivityKey) { Finish(); } else if (_activityKeyToGoBackTo != string.Empty) { _activityKeyToGoBackTo = string.Empty; } // If we are not on the page when the internet connection is lost, we need to update the UI if (!App.DeviceIsConnectedToInternet && OnConnectionStateChanged != null) { OnConnectionStateChanged.Invoke(false); } if (LoadingLayout != null) { LoadingLayout.BringToFront(); } base.OnResume(); stateOfLifeCycle = "Resume"; }
public async Task ConnectAsync() { ConnectionState = RXConnectionState.Connecting; OnConnectionStateChanged?.Invoke(this, ConnectionState); //Host is client if (DeviceService != null) { try { await DeviceService.ConnectAsync(); RfcommConnection = DeviceService.RfcommConnection; _ReadInputStreamTask = _ReadInputStreamTaskAsync(); ConnectionState = RXConnectionState.Connected; OnConnectionStateChanged?.Invoke(this, ConnectionState); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e); ConnectionState = RXConnectionState.Destoryed; OnConnectionStateChanged?.Invoke(this, ConnectionState); } } else { /*Host is Server*/ ConnectionState = RXConnectionState.Connected; _ReadInputStreamTask = _ReadInputStreamTaskAsync(); OnConnectionStateChanged?.Invoke(this, ConnectionState); } }
public Task ConnectAsync() { return(Task.Run(() => { ConnectionState = RXConnectionState.Connected; OnConnectionStateChanged?.Invoke(this, ConnectionState); })); }
private void SetConnectionState(ConnectionState state) { if (_connectionState == state) { return; } _connectionState = state; OnConnectionStateChanged?.Invoke(this, new ConnectionEventArgs(state)); }
public async Task HandleCommunicationAsync() { while (IsConnected) { await UpdateAsync(); OnConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(ConnectionState.Updated)); Thread.Sleep(updateIntervalInMs); } }
private void ChangeConnectionState(ConnectionState state) { if (State == state) { return; } State = state; // This method is called on a background thread; rerouting it to the Unity's thread. _synchronizationContext.Send(SafeInvoke, state); void SafeInvoke(object obj) => OnConnectionStateChanged?.Invoke((ConnectionState)obj); }
void BroadcastConnectionState(CallbackConnectionState NewState) { if (PreviouslyBroadcastedState == NewState) { return; } PreviouslyBroadcastedState = NewState; if (OnConnectionStateChanged != null) { OnConnectionStateChanged.Invoke(NewState); } }
private RTCPeerConnection(IJSRuntime jsRuntime, JsObjectRef jsObjectRef, RTCConfiguration rtcConfiguration) : base(jsRuntime, jsObjectRef) { AddNativeEventListener("connectionstatechange", (s, e) => OnConnectionStateChanged?.Invoke(s, e)); AddNativeEventListenerForObjectRef("datachannel", (s, e) => OnDataChannel?.Invoke(s, e), RTCDataChannelEvent.Create); AddNativeEventListenerForObjectRef("icecandidate", (s, e) => OnIceCandidate?.Invoke(s, e), RTCPeerConnectionIceEvent.Create); AddNativeEventListener("iceconnectionstatechange", (s, e) => OnIceConnectionStateChange?.Invoke(s, e)); AddNativeEventListener("icegatheringstatechange", (s, e) => OnIceGatheringStateChange?.Invoke(s, e)); AddNativeEventListener("negotiationneeded", (s, e) => OnNegotiationNeeded?.Invoke(s, e)); AddNativeEventListener("signallingstatechange", (s, e) => OnSignallingStateChange?.Invoke(s, e)); AddNativeEventListenerForObjectRef("track", (s, e) => OnTrack?.Invoke(s, e), RTCTrackEvent.Create); }
private void OnConnectivityChanged(object sender, Plugin.Connectivity.Abstractions.ConnectivityChangedEventArgs e) { if (AppInformationLayout != null) { AppInformationLayout.Visibility = e.IsConnected ? ViewStates.Gone : ViewStates.Visible; OnConnectionStateChanged?.Invoke(e.IsConnected); } if (e.IsConnected) { App.Locator.ListSeekios.SubscribeToSignalR(); App.Locator.ListSeekios.LoadUserEnvironment(DeviceInfoHelper.DeviceModel , DeviceInfoHelper.Platform , DeviceInfoHelper.Version , DeviceInfoHelper.GetDeviceUniqueId(this) , DeviceInfoHelper.CountryCode); } }
public Client(string ip, int port, int updateIntervalInMs = 100) { client = new TcpClient() { NoDelay = true, }; this.updateIntervalInMs = updateIntervalInMs; client.Connect(ip, port); IsConnected = true; StreamWriter = new StreamWriter(client.GetStream()); StreamReader = new StreamReader(client.GetStream()); OnConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(ConnectionState.Connected)); OnConnected?.Invoke(this, null); }
protected virtual void OnConnectionStateChangedHandler(StateChange change) { ConnectionState = change.NewState; OnConnectionStateChanged?.Invoke(change); if (!change.NewState.Equals(ConnectionState.Disconnected)) { return; } // SignalR doesn´t do anything after disconnected state, so we need to manually reconnect if (_timer == null) { _timer = new SimpleTimer(TimeSpan.FromSeconds(_secondsToReconnect), async() => { DismissCurrentConnection(); await Connect(); }, true); } _timer.Start(); }
void AgoraRtcEventHandler.OnConnectionStateChanged(CONNECTION_STATE_TYPE type, CONNECTION_CHANGED_REASON_TYPE reason) { OnConnectionStateChanged?.Invoke(type, reason); }
internal void ProcessMessage(BinaryReader br) { // Any message starts with an 1-byte command type var messageType = (InboundMessageTypes)br.ReadByte(); switch (messageType) { case InboundMessageTypes.REGISTRATION_RESULT: { ConnectionId = br.ReadInt32(); var connectionSuccess = br.ReadByte() > 0; var isReadonly = br.ReadByte() == 0; var errMsg = ReadString(br); OnConnectionStateChanged?.Invoke(ConnectionId, connectionSuccess, isReadonly, errMsg); // In case this was successful, we will request the initial data RequestEntryList(); RequestTrackData(); } break; case InboundMessageTypes.ENTRY_LIST: { _entryListCars.Clear(); var connectionId = br.ReadInt32(); var carEntryCount = br.ReadUInt16(); for (int i = 0; i < carEntryCount; i++) { _entryListCars.Add(new CarInfo(br.ReadUInt16())); } } break; case InboundMessageTypes.ENTRY_LIST_CAR: { var carId = br.ReadUInt16(); var carInfo = _entryListCars.SingleOrDefault(x => x.CarIndex == carId); if (carInfo == null) { System.Diagnostics.Debug.WriteLine($"Entry list update for unknown carIndex {carId}"); break; } carInfo.CarModelType = br.ReadByte(); // Byte sized car model carInfo.TeamName = ReadString(br); carInfo.RaceNumber = br.ReadInt32(); carInfo.CupCategory = br.ReadByte(); // Cup: Overall/Pro = 0, ProAm = 1, Am = 2, Silver = 3, National = 4 carInfo.CurrentDriverIndex = br.ReadByte(); carInfo.Nationality = (NationalityEnum)br.ReadUInt16(); // Now the drivers on this car: var driversOnCarCount = br.ReadByte(); for (int di = 0; di < driversOnCarCount; di++) { var driverInfo = new DriverInfo(); driverInfo.FirstName = ReadString(br); driverInfo.LastName = ReadString(br); driverInfo.ShortName = ReadString(br); driverInfo.Category = (DriverCategory)br.ReadByte(); // Platinum = 3, Gold = 2, Silver = 1, Bronze = 0 // new in 1.13.11: driverInfo.Nationality = (NationalityEnum)br.ReadUInt16(); carInfo.AddDriver(driverInfo); } OnEntrylistUpdate?.Invoke(ConnectionIdentifier, carInfo); } break; case InboundMessageTypes.REALTIME_UPDATE: { RealtimeUpdate update = new RealtimeUpdate(); update.EventIndex = (int)br.ReadUInt16(); update.SessionIndex = (int)br.ReadUInt16(); update.SessionType = (RaceSessionType)br.ReadByte(); update.Phase = (SessionPhase)br.ReadByte(); var sessionTime = br.ReadSingle(); update.SessionTime = TimeSpan.FromMilliseconds(sessionTime); var sessionEndTime = br.ReadSingle(); update.SessionEndTime = TimeSpan.FromMilliseconds(sessionEndTime); update.FocusedCarIndex = br.ReadInt32(); update.ActiveCameraSet = ReadString(br); update.ActiveCamera = ReadString(br); update.CurrentHudPage = ReadString(br); update.IsReplayPlaying = br.ReadByte() > 0; if (update.IsReplayPlaying) { update.ReplaySessionTime = br.ReadSingle(); update.ReplayRemainingTime = br.ReadSingle(); } update.TimeOfDay = TimeSpan.FromMilliseconds(br.ReadSingle()); update.AmbientTemp = br.ReadByte(); update.TrackTemp = br.ReadByte(); update.Clouds = br.ReadByte() / 10.0f; update.RainLevel = br.ReadByte() / 10.0f; update.Wetness = br.ReadByte() / 10.0f; update.BestSessionLap = ReadLap(br); OnRealtimeUpdate?.Invoke(ConnectionIdentifier, update); } break; case InboundMessageTypes.REALTIME_CAR_UPDATE: { RealtimeCarUpdate carUpdate = new RealtimeCarUpdate(); carUpdate.CarIndex = br.ReadUInt16(); carUpdate.DriverIndex = br.ReadUInt16(); // Driver swap will make this change carUpdate.DriverCount = br.ReadByte(); carUpdate.Gear = br.ReadByte() - 2; // -2 makes the R -1, N 0 and the rest as-is carUpdate.WorldPosX = br.ReadSingle(); carUpdate.WorldPosY = br.ReadSingle(); carUpdate.Yaw = br.ReadSingle(); carUpdate.CarLocation = (CarLocationEnum)br.ReadByte(); // - , Track, Pitlane, PitEntry, PitExit = 4 carUpdate.Kmh = br.ReadUInt16(); carUpdate.Position = br.ReadUInt16(); // official P/Q/R position (1 based) carUpdate.CupPosition = br.ReadUInt16(); // official P/Q/R position (1 based) carUpdate.TrackPosition = br.ReadUInt16(); // position on track (1 based) carUpdate.SplinePosition = br.ReadSingle(); // track position between 0.0 and 1.0 carUpdate.Laps = br.ReadUInt16(); carUpdate.Delta = br.ReadInt32(); // Realtime delta to best session lap carUpdate.BestSessionLap = ReadLap(br); carUpdate.LastLap = ReadLap(br); carUpdate.CurrentLap = ReadLap(br); // the concept is: "don't know a car or driver? ask for an entry list update" var carEntry = _entryListCars.FirstOrDefault(x => x.CarIndex == carUpdate.CarIndex); if (carEntry == null || carEntry.Drivers.Count != carUpdate.DriverCount) { if ((DateTime.Now - lastEntrylistRequest).TotalSeconds > 1) { lastEntrylistRequest = DateTime.Now; RequestEntryList(); System.Diagnostics.Debug.WriteLine($"CarUpdate {carUpdate.CarIndex}|{carUpdate.DriverIndex} not know, will ask for new EntryList"); } } else { OnRealtimeCarUpdate?.Invoke(ConnectionIdentifier, carUpdate); } } break; case InboundMessageTypes.TRACK_DATA: { var connectionId = br.ReadInt32(); var trackData = new TrackData(); trackData.TrackName = ReadString(br); trackData.TrackId = br.ReadInt32(); trackData.TrackMeters = br.ReadInt32(); TrackMeters = trackData.TrackMeters > 0 ? trackData.TrackMeters : -1; trackData.CameraSets = new Dictionary <string, List <string> >(); var cameraSetCount = br.ReadByte(); for (int camSet = 0; camSet < cameraSetCount; camSet++) { var camSetName = ReadString(br); trackData.CameraSets.Add(camSetName, new List <string>()); var cameraCount = br.ReadByte(); for (int cam = 0; cam < cameraCount; cam++) { var cameraName = ReadString(br); trackData.CameraSets[camSetName].Add(cameraName); } } var hudPages = new List <string>(); var hudPagesCount = br.ReadByte(); for (int i = 0; i < hudPagesCount; i++) { hudPages.Add(ReadString(br)); } trackData.HUDPages = hudPages; OnTrackDataUpdate?.Invoke(ConnectionIdentifier, trackData); } break; case InboundMessageTypes.BROADCASTING_EVENT: { BroadcastingEvent evt = new BroadcastingEvent() { Type = (BroadcastingCarEventType)br.ReadByte(), Msg = ReadString(br), TimeMs = br.ReadInt32(), CarId = br.ReadInt32(), }; evt.CarData = _entryListCars.FirstOrDefault(x => x.CarIndex == evt.CarId); OnBroadcastingEvent?.Invoke(ConnectionIdentifier, evt); } break; default: break; } }
// This event is optional in iOS. Decide about the connection in 'DidChangeIceConnectionState'. public void DidChangeConnectionState(Webrtc.RTCPeerConnection peerConnection, Webrtc.RTCPeerConnectionState newState) { //System.Diagnostics.Debug.WriteLine($"=============================== PeerConnection.RTCPeerConnectionState: {newState}"); OnConnectionStateChanged?.Invoke(this, EventArgs.Empty); }
protected async void StartConnection() { await _hub.StartAsync(); await OnConnectionStateChanged.Invoke("Connected to hub"); }
protected async Task InvokeConnectionStateChanged(Exception e) { await OnConnectionStateChanged.Invoke(e.Message); }
public void OnIceConnectionChange(Webrtc.PeerConnection.IceConnectionState p0) { OnIceConnectionStateChange?.Invoke(this, EventArgs.Empty); // !!! I don't know why Android DOES NOT provide Connection State Change event??? // I drive this event from Ice Connection State Change event here for now. #if false if (p0 == Webrtc.PeerConnection.IceConnectionState.New) { } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Checking) { } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Connected) { Timer timer = null; int count = 5; // Make sure that state is connected with several attempts. timer = new Timer(new TimerCallback((state) => { if (((Webrtc.PeerConnection)NativeObject).ConnectionState() == Webrtc.PeerConnection.PeerConnectionState.Connected || --count == 0) { timer.Dispose(); System.Diagnostics.Debug.WriteLine($"OOOOOOOOOOOOOOOOOOOOOOO PeerConnection GENERATED CONNECTED {count}"); OnConnectionStateChanged?.Invoke(this, EventArgs.Empty); return; } }), null, 10, 50); return; } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Completed) { } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Failed) { } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Disconnected) { Timer timer = null; int count = 5; // Make sure that state is disconnected with several attempsts. timer = new Timer(new TimerCallback((state) => { if (((Webrtc.PeerConnection)NativeObject).ConnectionState() == Webrtc.PeerConnection.PeerConnectionState.Disconnected || --count == 0) { timer.Dispose(); OnConnectionStateChanged?.Invoke(this, EventArgs.Empty); return; } }), null, 10, 50); return; } else if (p0 == Webrtc.PeerConnection.IceConnectionState.Closed) { } #endif if (p0 == PeerConnection.IceConnectionState.Connected || p0 == PeerConnection.IceConnectionState.Completed) { if (!_isConnected) { _isConnected = true; OnConnectionStateChanged?.Invoke(this, EventArgs.Empty); } } else if (_isConnected) { _isConnected = false; OnConnectionStateChanged?.Invoke(this, EventArgs.Empty); } }
public async Task ReconectAsync() { await _hub.StartAsync(); await OnConnectionStateChanged.Invoke("Connected to hub"); }
private void HubConnection_StateChanged(StateChange obj) { OnConnectionStateChanged?.Invoke(obj); }