public async Task DisconnectFromClientNetwork(string networkSsid)
{
if (_ConnectedSocket == null)
{
return;
}
var disconnectRequest = new CompanionAppCommunication()
{
Verb = "DisconnectFromNetwork", Data = networkSsid
};
// Send request to disconnect to network
WriteToSocket(disconnectRequest);
// Read response with available networks
var networkResponse = await GetNextRequest();
if (networkResponse != null && networkResponse.Verb == "DisconnectResult")
{
if (ClientNetworkConnectedEvent != null)
{
ClientNetworkConnectedEvent(networkResponse.Data);
}
}
}
public async Task ConnectToClientNetwork(string networkSsid, string password)
{
if (_ConnectedSocket == null)
{
return;
}
var connectRequest = new CompanionAppCommunication()
{
Verb = "ConnectToNetwork", Data = string.Format("{0}={1}", networkSsid, password)
};
// Send request to connect to network
WriteToSocket(connectRequest);
// Read response with available networks
var networkResponse = await GetNextRequest();
if (networkResponse != null && networkResponse.Verb == "ConnectResult")
{
if (ClientNetworkConnectedEvent != null)
{
ClientNetworkConnectedEvent(networkResponse.Data);
}
}
}
public async Task RequestClientNetworks(ObservableCollection <Network> availableNetworks)
{
if (_ConnectedSocket == null)
{
return;
}
var waitForClear = new AutoResetEvent(false);
Device.BeginInvokeOnMainThread(() => {
availableNetworks.Clear();
waitForClear.Set();
});
waitForClear.WaitOne();
var networkRequest = new CompanionAppCommunication()
{
Verb = "GetAvailableNetworks"
};
// Send request for available networks
WriteToSocket(networkRequest);
// Read response with available networks
var networkResponse = await GetNextRequest();
if (networkResponse != null && networkResponse.Verb == "AvailableNetworks")
{
var availableNetworkArray = JsonToStringList(networkResponse.Data);
availableNetworkArray.ForEach(availableNetwork => {
var network = new Network()
{
Ssid = availableNetwork
};
Device.BeginInvokeOnMainThread(() => {
availableNetworks.Add(network);
waitForClear.Set();
});
waitForClear.WaitOne();
});
}
if (ClientNetworksEnumeratedEvent != null)
{
ClientNetworksEnumeratedEvent("Enumerated");
}
}
private async Task <CompanionAppCommunication> GetNextRequest()
{
CompanionAppCommunication msg = null;
await _SocketLock.WaitAsync();
try
{
byte[] resp = new byte[2048];
var memStream = new MemoryStream();
var bytes = 0;
do
{
bytes = _NetworkStream.Read(resp, 0, resp.Length);
memStream.Write(resp, 0, bytes);
} while (_NetworkStream.DataAvailable);
ASCIIEncoding asen = new ASCIIEncoding();
var data = asen.GetString(memStream.ToArray());
//
// In this sample, protected information is sent over the channel
// as plain text. This data needs to be protcted with encryption
// based on a trust relationship between the Companion App client
// and server.
//
if (data.Length != 0)
{
Debug.WriteLine(string.Format("incoming request {0}", data));
var jsonData = Newtonsoft.Json.Linq.JObject.Parse(data);
msg = new CompanionAppCommunication()
{
Verb = (string)jsonData["Verb"],
Data = (string)jsonData["Data"]
};
}
}
finally
{
_SocketLock.Release();
}
return(msg);
}
public async Task RequestClientNetworks(ObservableCollection <Network> availableNetworks)
{
if (_ConnectedSocket == null)
{
return;
}
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
availableNetworks.Clear();
});
var networkRequest = new CompanionAppCommunication()
{
Verb = "GetAvailableNetworks"
};
// Send request for available networks
await SendRequest(networkRequest);
// Read response with available networks
var networkResponse = await GetNextRequest();
if (networkResponse != null && networkResponse.Verb == "AvailableNetworks")
{
var availableNetworkArray = Dejsonify(typeof(string[]), networkResponse.Data) as string[];
availableNetworkArray.OrderBy(x => x).Distinct().ToList().ForEach(async availableNetwork => {
var network = new Network()
{
Ssid = availableNetwork
};
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
availableNetworks.Add(network);
});
});
}
if (ClientNetworksEnumeratedEvent != null)
{
ClientNetworksEnumeratedEvent("Enumerated");
}
}
private async Task <CompanionAppCommunication> GetNextRequest()
{
CompanionAppCommunication msg = null;
await _SocketLock.WaitAsync();
try
{
await _DataReader.LoadAsync(1024);
string data = string.Empty;
while (_DataReader.UnconsumedBufferLength > 0)
{
data += _DataReader.ReadString(_DataReader.UnconsumedBufferLength);
}
//
// In this sample, protected information is sent over the channel
// as plain text. This data needs to be protcted with encryption
// based on a trust relationship between the Companion App client
// and server.
//
if (data.Length != 0)
{
Debug.WriteLine(string.Format("incoming request {0}", data));
using (var stream = new MemoryStream(Encoding.Unicode.GetBytes(data)))
{
var serializer = new DataContractJsonSerializer(typeof(CompanionAppCommunication));
msg = serializer.ReadObject(stream) as CompanionAppCommunication;
}
}
}
finally
{
_SocketLock.Release();
}
return(msg);
}
private async Task SendRequest(CompanionAppCommunication communication)
{
//
// In this sample, protected information is sent over the channel
// as plain text. This data needs to be protcted with encryption
// based on a trust relationship between the Companion App client
// and server.
//
await _SocketLock.WaitAsync();
try
{
string requestData = Jsonify(typeof(CompanionAppCommunication), communication);
_DataWriter.WriteString(requestData);
await _DataWriter.StoreAsync();
Debug.WriteLine(string.Format("Sent: {0}", requestData));
}
finally
{
_SocketLock.Release();
}
}
private void WriteToSocket(CompanionAppCommunication communication)
{
//
// In this sample, protected information is sent over the channel
// as plain text. This data needs to be protcted with encryption
// based on a trust relationship between the Companion App client
// and server.
//
_SocketLock.Wait();
try
{
var data = Jsonify(communication);
ASCIIEncoding asen = new ASCIIEncoding();
byte[] ba = asen.GetBytes(data);
_NetworkStream.Write(ba, 0, ba.Length);
Debug.WriteLine(string.Format("Sent: {0}", data));
}
finally
{
_SocketLock.Release();
}
}
public async Task RequestClientNetworks(ObservableCollection <Network> availableNetworks)
{
if (_ConnectedSocket == null)
{
return;
}
// Assumes thread ID of main thread is 1 for Android
var isMainThread = (Thread.CurrentThread.ManagedThreadId == 1);
var waitForClear = new AutoResetEvent(false);
Action clearAction = () => {
availableNetworks.Clear();
waitForClear.Set();
};
if (isMainThread)
{
clearAction.Invoke();
}
else
{
Device.BeginInvokeOnMainThread(clearAction);
waitForClear.WaitOne();
}
var networkRequest = new CompanionAppCommunication()
{
Verb = "GetAvailableNetworks"
};
// Send request for available networks
WriteToSocket(networkRequest);
// Read response with available networks
var networkResponse = await GetNextRequest();
if (networkResponse != null && networkResponse.Verb == "AvailableNetworks")
{
var availableNetworkArray = JsonToStringList(networkResponse.Data);
availableNetworkArray.ForEach(availableNetwork => {
var network = new Network()
{
Ssid = availableNetwork
};
Action addAction = () => { availableNetworks.Add(network); };
if (isMainThread)
{
addAction.Invoke();
}
else
{
Device.BeginInvokeOnMainThread(addAction);
}
});
}
if (ClientNetworksEnumeratedEvent != null)
{
ClientNetworksEnumeratedEvent("Enumerated");
}
}
