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);
}
