public override async void Connect()
{
try
{
foreach (var current in BackgroundTaskRegistration.AllTasks)
{
if (current.Value.Name == BackgroundTaskName)
{
task = current.Value;
break;
}
}
if (task == null)
{
var socketTaskBuilder = new BackgroundTaskBuilder();
socketTaskBuilder.Name = "WinIRCBackgroundTask." + server.name;
var trigger = new SocketActivityTrigger();
socketTaskBuilder.SetTrigger(trigger);
task = socketTaskBuilder.Register();
}
}
catch
{
// empty catch
}
streamSocket = new StreamSocket();
streamSocket.Control.KeepAlive = true;
dataStreamLineReader = new SafeLineReader();
try
{
if (task != null)
{
streamSocket.EnableTransferOwnership(task.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
var protectionLevel = server.ssl ? SocketProtectionLevel.Tls12 : SocketProtectionLevel.PlainSocket;
Debug.WriteLine("Attempting to connect...");
await streamSocket.ConnectAsync(new Windows.Networking.HostName(server.hostname), server.port.ToString(), protectionLevel);
Debug.WriteLine("Connected!");
reader = new DataReader(streamSocket.InputStream);
writer = new DataWriter(streamSocket.OutputStream);
IsConnected = true;
ConnectionHandler();
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
return;
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
try
{
var details = taskInstance.TriggerDetails as SocketActivityTriggerDetails;
var socketInformation = details.SocketInformation;
switch (details.Reason)
{
case SocketActivityTriggerReason.SocketActivity:
var socket = socketInformation.StreamSocket;
DataReader reader = new DataReader(socket.InputStream);
reader.InputStreamOptions = InputStreamOptions.Partial;
await reader.LoadAsync(250);
var dataString = reader.ReadString(reader.UnconsumedBufferLength);
ShowToast(dataString);
socket.TransferOwnership(socketInformation.Id);
break;
case SocketActivityTriggerReason.KeepAliveTimerExpired:
socket = socketInformation.StreamSocket;
DataWriter writer = new DataWriter(socket.OutputStream);
writer.WriteBytes(Encoding.UTF8.GetBytes("Keep alive"));
await writer.StoreAsync();
writer.DetachStream();
writer.Dispose();
socket.TransferOwnership(socketInformation.Id);
break;
case SocketActivityTriggerReason.SocketClosed:
socket = new StreamSocket();
socket.EnableTransferOwnership(taskInstance.Task.TaskId, SocketActivityConnectedStandbyAction.Wake);
if (ApplicationData.Current.LocalSettings.Values["hostname"] == null)
{
break;
}
var hostname = (String)ApplicationData.Current.LocalSettings.Values["hostname"];
var port = (String)ApplicationData.Current.LocalSettings.Values["port"];
await socket.ConnectAsync(new HostName(hostname), port);
socket.TransferOwnership(socketId);
break;
default:
break;
}
deferral.Complete();
}
catch (Exception exception)
{
ShowToast(exception.Message);
deferral.Complete();
}
}
private async void CreateSocket()
{
try
{
HostName hostName = new HostName("192.168.2.116");
_clientSocket = new StreamSocket();
_clientSocket.Control.NoDelay = false;
if (_bgSocketask != null)
{
//EnableTransferOwnership
_clientSocket.EnableTransferOwnership(_bgSocketask.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
//Connect the Server socket
await _clientSocket.ConnectAsync(hostName, "6000");
Stream streamOut = _clientSocket.OutputStream.AsStreamForWrite();
StreamWriter writer = new StreamWriter(streamOut);
string request = "test";
await writer.WriteLineAsync(request);
await writer.FlushAsync();
while (send)
{
var reader = new DataReader(_clientSocket.InputStream)
{
InputStreamOptions = InputStreamOptions.Partial
};
//Read the packet information
await reader.LoadAsync(256);
var response = reader.ReadString(reader.UnconsumedBufferLength);
reader.DetachStream();
//Display in GUI
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
dataInfo.Add(response);
});
}
}
catch (Exception)
{
}
}
private async void ConnectButton_Click(object sender, RoutedEventArgs e)
{
ApplicationData.Current.LocalSettings.Values["hostname"] = TargetServerTextBox.Text;
ApplicationData.Current.LocalSettings.Values["port"] = port;
try
{
SocketActivityInformation socketInformation;
if (!SocketActivityInformation.AllSockets.TryGetValue(socketId, out socketInformation))
{
socket = new StreamSocket();
socket.EnableTransferOwnership(task.TaskId, SocketActivityConnectedStandbyAction.Wake);
var targetServer = new HostName(TargetServerTextBox.Text);
await socket.ConnectAsync(targetServer, port);
#if false
// To demonstrate usage of CancelIOAsync async, have a pending read on the socket and call
// cancel before transfering the socket.
DataReader reader = new DataReader(socket.InputStream);
reader.InputStreamOptions = InputStreamOptions.Partial;
var read = reader.LoadAsync(250);
read.Completed += (info, status) =>
{
};
await socket.CancelIOAsync();
socket.TransferOwnership(socketId);
socket = null;
#endif
}
ConnectButton.IsEnabled = false;
rootPage.NotifyUser("Connected. You may close the application", NotifyType.StatusMessage);
}
catch (Exception exception)
{
rootPage.NotifyUser(exception.Message, NotifyType.ErrorMessage);
}
}
public IAsyncOperation <ConnectionStatus> ConnectToSignalingServerAsync(ConnectionOwner connectionOwner)
{
return(Task.Run(async() =>
{
try
{
SignaledPeerData.Reset();
SignalingStatus.Reset();
await SignaledInstantMessages.ResetAsync();
var socket = new StreamSocket();
socket.EnableTransferOwnership(Guid.Parse(connectionOwner.OwnerId),
SocketActivityConnectedStandbyAction.Wake);
var connectCancellationTokenSource = new CancellationTokenSource(2000);
var connectAsync = socket.ConnectAsync(new HostName(SignalingSettings.SignalingServerHost),
SignalingSettings.SignalingServerPort, SocketProtectionLevel.PlainSocket);
var connectTask = connectAsync.AsTask(connectCancellationTokenSource.Token);
await connectTask;
socket.TransferOwnership(SignalingSocketOperation.SignalingSocketId);
return new ConnectionStatus
{
IsConnected = true
};
}
catch (Exception exception)
{
Debug.WriteLine("Failed to connect to signalling server: ex: " + exception.Message);
return new ConnectionStatus
{
IsConnected = false
};
}
}).AsAsyncOperation());
}
public override async void Connect()
{
var autoReconnect = Config.GetBoolean(Config.AutoReconnect, true);
if (Server == null)
{
return;
}
try
{
foreach (var current in BackgroundTaskRegistration.AllTasks)
{
if (current.Value.Name == BackgroundTaskName)
{
task = current.Value;
break;
}
}
if (task == null)
{
var socketTaskBuilder = new BackgroundTaskBuilder();
socketTaskBuilder.Name = "WinIRCBackgroundTask." + Server.Name;
var trigger = new SocketActivityTrigger();
socketTaskBuilder.SetTrigger(trigger);
//task = socketTaskBuilder.Register();
}
}
catch (Exception e)
{
Debug.WriteLine(e);
}
IsAuthed = false;
ReadOrWriteFailed = false;
if (!ConnCheck.HasInternetAccess)
{
var msg = autoReconnect
? "We'll try to connect once a connection is available."
: "Please try again once your connection is restored";
var error = IrcUWPBase.CreateBasicToast("No connection detected.", msg);
error.ExpirationTime = DateTime.Now.AddDays(2);
ToastNotificationManager.CreateToastNotifier().Show(error);
if (!autoReconnect)
{
DisconnectAsync(attemptReconnect: autoReconnect);
}
return;
}
streamSocket = new StreamSocket();
streamSocket.Control.KeepAlive = true;
if (Config.GetBoolean(Config.IgnoreSSL))
{
streamSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
streamSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Expired);
}
if (task != null)
{
streamSocket.EnableTransferOwnership(task.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
dataStreamLineReader = new SafeLineReader();
try
{
var protectionLevel = Server.Ssl ? SocketProtectionLevel.Tls12 : SocketProtectionLevel.PlainSocket;
Debug.WriteLine("Attempting to connect...");
await streamSocket.ConnectAsync(new Windows.Networking.HostName(Server.Hostname), Server.Port.ToString(), protectionLevel);
Debug.WriteLine("Connected!");
reader = new DataReader(streamSocket.InputStream);
writer = new DataWriter(streamSocket.OutputStream);
IsConnected = true;
IsConnecting = false;
ConnectionHandler();
}
catch (Exception e)
{
var msg = autoReconnect
? "Attempting to reconnect..."
: "Please try again later.";
AddError("Error whilst connecting: " + e.Message + "\n" + msg);
AddError(e.StackTrace);
AddError("If this error keeps occuring, ensure your connection settings are correct.");
DisconnectAsync(attemptReconnect: autoReconnect);
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
}
}
public async Task StartFresh(bool withBG)
{
try
{
Log($"[{_instaApi.GetLoggedUser().UserName}] " + "Starting fresh");
var connectPacket = new FbnsConnectPacket
{
Payload = await PayloadProcessor.BuildPayload(ConnectionData)
};
Socket = new StreamSocket();
Socket.Control.KeepAlive = true;
Socket.Control.NoDelay = true;
if (await RequestBackgroundAccess() && !withBG)
{
OnlyOnce = false;
if (CanRunInBG())
{
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
catch (Exception connectedStandby)
{
Log(connectedStandby);
Log($"[{_instaApi.GetLoggedUser().UserName}] " + "Connected standby not available");
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.DoNotWake);
}
catch (Exception e)
{
Log(e);
Log($"[{_instaApi.GetLoggedUser().UserName}] " + "Failed to transfer socket completely!");
if (RetryConnection > 3)
{
Shutdown();
await StartFresh(true);
RetryConnection++;
return;
}
return;
}
}
}
}
_runningTokenSource = new CancellationTokenSource();
await Socket.ConnectAsync(new HostName(HOST_NAME), "443", SocketProtectionLevel.Tls12);
_inboundReader = new DataReader(Socket.InputStream);
_outboundWriter = new DataWriter(Socket.OutputStream);
_inboundReader.ByteOrder = ByteOrder.BigEndian;
_inboundReader.InputStreamOptions = InputStreamOptions.Partial;
_outboundWriter.ByteOrder = ByteOrder.BigEndian;
await Task.Delay(2500);
await FbnsPacketEncoder.EncodePacket(connectPacket, _outboundWriter);
await Task.Delay(2500);
StartPollingLoop();
}
catch (Exception ex)
{
PrintException("StartFresh", ex);
Shutdown();
if (!OnlyOnce)
{
OnlyOnce = true;
await StartFresh(true);
}
}
}
public async Task StartFresh()
{
this.Log("Starting fresh");
if (!Instagram.InternetAvailable())
{
this.Log("Internet not available. Exiting.");
return;
}
if (Running)
{
throw new Exception("Push client is already running");
}
var connectPacket = new FbnsConnectPacket
{
Payload = await PayloadProcessor.BuildPayload(ConnectionData)
};
Socket = new StreamSocket();
Socket.Control.KeepAlive = true;
Socket.Control.NoDelay = true;
if (await RequestBackgroundAccess())
{
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
catch (Exception connectedStandby)
{
this.Log(connectedStandby);
this.Log("Connected standby not available");
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.DoNotWake);
}
catch (Exception e)
{
DebugLogger.LogException(e);
this.Log("Failed to transfer socket completely!");
return;
}
}
}
else
{
// if cannot get background access then there is no point of running push client
return;
}
try
{
await Socket.ConnectAsync(new HostName(HOST_NAME), "443", SocketProtectionLevel.Tls12);
_inboundReader = new DataReader(Socket.InputStream);
_outboundWriter = new DataWriter(Socket.OutputStream);
_inboundReader.ByteOrder = ByteOrder.BigEndian;
_inboundReader.InputStreamOptions = InputStreamOptions.Partial;
_outboundWriter.ByteOrder = ByteOrder.BigEndian;
_runningTokenSource = new CancellationTokenSource();
await FbnsPacketEncoder.EncodePacket(connectPacket, _outboundWriter);
}
catch (Exception e)
{
DebugLogger.LogException(e);
Restart();
return;
}
StartPollingLoop();
}
public async Task StartFresh()
{
try
{
Debug.WriteLine($"{nameof(PushClient)}: Starting fresh.");
if (_loopGroup != null)
{
await Shutdown();
}
_loopGroup = new SingleThreadEventLoop();
var connectPacket = new FbnsConnectPacket
{
Payload = await PayloadProcessor.BuildPayload(ConnectionData)
};
Socket = new StreamSocket();
Socket.Control.KeepAlive = true;
Socket.Control.NoDelay = true;
if (await RequestBackgroundAccess())
{
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.Wake);
}
catch (Exception connectedStandby)
{
Debug.WriteLine(connectedStandby);
Debug.WriteLine($"{nameof(PushClient)}: Connected standby not available.");
try
{
Socket.EnableTransferOwnership(_socketActivityTask.TaskId, SocketActivityConnectedStandbyAction.DoNotWake);
}
catch (Exception e)
{
#if !DEBUG
Crashes.TrackError(e);
#endif
Debug.WriteLine(e);
Debug.WriteLine($"{nameof(PushClient)}: Failed to transfer socket completely!");
await Shutdown().ConfigureAwait(false);
return;
}
}
}
await Socket.ConnectAsync(new HostName(HOST_NAME), "443", SocketProtectionLevel.Tls12);
var streamSocketChannel = new StreamSocketChannel(Socket);
streamSocketChannel.Pipeline.AddLast(new FbnsPacketEncoder(), new FbnsPacketDecoder(), this);
await _loopGroup.RegisterAsync(streamSocketChannel).ConfigureAwait(false);
await streamSocketChannel.WriteAndFlushAsync(connectPacket).ConfigureAwait(false);
}
catch (Exception e)
{
#if !DEBUG
Crashes.TrackError(e);
#endif
await Shutdown().ConfigureAwait(false);
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
try
{
var details = taskInstance.TriggerDetails as SocketActivityTriggerDetails;
var socketInformation = details.SocketInformation;
switch (details.Reason)
{
case SocketActivityTriggerReason.SocketActivity:
var socket = socketInformation.StreamSocket;
DataReader dataReader = new DataReader(socket.InputStream);
dataReader.InputStreamOptions = InputStreamOptions.Partial;
// wait for first 4 bytes to get content size
UInt32 stringHeader = await dataReader.LoadAsync(4);
if (stringHeader != 0)
{
// getting content size
byte[] bytes = new byte[4];
dataReader.ReadBytes(bytes);
int length = BitConverter.ToInt32(bytes, 0);
// read avaliable content
uint count = await dataReader.LoadAsync((uint)length);
byte[] receivedBytes = new byte[count];
dataReader.ReadBytes(receivedBytes);
// TO DO
// manipulate with received Bytes
ShowToast("Data received");
}
socket.TransferOwnership(socketInformation.Id);
break;
case SocketActivityTriggerReason.KeepAliveTimerExpired:
socket = socketInformation.StreamSocket;
DataWriter writer = new DataWriter(socket.OutputStream);
writer.WriteBytes(Encoding.UTF8.GetBytes("Keep alive"));
await writer.StoreAsync();
writer.DetachStream();
writer.Dispose();
socket.TransferOwnership(socketInformation.Id);
break;
case SocketActivityTriggerReason.SocketClosed:
socket = new StreamSocket();
socket.EnableTransferOwnership(taskInstance.Task.TaskId, SocketActivityConnectedStandbyAction.Wake);
if (ApplicationData.Current.LocalSettings.Values["hostname"] == null)
{
break;
}
var hostname = (String)ApplicationData.Current.LocalSettings.Values["hostname"];
var port = (String)ApplicationData.Current.LocalSettings.Values["port"];
await socket.ConnectAsync(new HostName(hostname), port);
socket.TransferOwnership(socketId);
break;
default:
break;
}
deferral.Complete();
}
catch (Exception exception)
{
ShowToast(exception.Message);
deferral.Complete();
}
}