protected virtual void OnDeviceUpdated(CompanionConnectionManager m, CompanionDevice d)
{
if (CompanionDeviceUpdated != null)
{
CompanionDeviceUpdated(m, d);
}
}
CompanionDevice GetCompanionDeviceFromParameters(Dictionary <string, string> Parameters)
{
CompanionDevice d = null;
if ((Parameters != null) && (Parameters.ContainsKey(CompanionProtocol.parameterName)) &&
(Parameters.ContainsKey(CompanionProtocol.parameterIPAddress)) &&
(Parameters.ContainsKey(CompanionProtocol.parameterKind)) &&
(Parameters.ContainsKey(CompanionProtocol.parameterID))
)
{
string Name = Parameters[CompanionProtocol.parameterName];
if (Name != null)
{
string IP = Parameters[CompanionProtocol.parameterIPAddress];
if (IP != null)
{
string Kind = Parameters[CompanionProtocol.parameterKind];
if (Kind != null)
{
string Id = Parameters[CompanionProtocol.parameterID];
if (Id != null)
{
d = new CompanionDevice(Id, false, Name, IP, Kind);
}
}
}
}
}
return(d);
}
// Summary:
// Check if the device is connected (a ping have been successful)
public virtual bool IsCompanionDeviceConnected(CompanionDevice cd)
{
if ((listCompanionDevices.ContainsKey(cd.Id)) && (listRemoteSystems.ContainsKey(cd.Id)))
{
return(listCompanionDevices[cd.Id].Status == CompanionDeviceStatus.Connected);
}
return(false);
}
// Summary:
// Initialize CompanionConnectionManager
public virtual async System.Threading.Tasks.Task <bool> Initialize(CompanionDevice LocalDevice, CompanionConnectionManagerInitializeArgs InitArgs)
{
LocalCompanionDevice = LocalDevice;
ApplicationUri = InitArgs.ApplicationUri;
AppServiceName = InitArgs.AppServiceName;
PackageFamilyName = InitArgs.PackageFamilyName;
if (listCompanionDevices == null)
{
listCompanionDevices = new Dictionary <string, CompanionDevice>();
}
if (listRemoteSystems == null)
{
listRemoteSystems = new Dictionary <string, RemoteSystem>();
}
//Set up a new app service connection
if (receiveConnection != null)
{
receiveConnection.ServiceClosed -= ReceiveConnection_ServiceClosed;
receiveConnection.RequestReceived -= ReceiveConnection_RequestReceived;
receiveConnection = null;
}
receiveConnection = new AppServiceConnection();
if (receiveConnection != null)
{
receiveConnection.AppServiceName = AppServiceName;
receiveConnection.PackageFamilyName = PackageFamilyName;
receiveConnection.RequestReceived += ReceiveConnection_RequestReceived;
receiveConnection.ServiceClosed += ReceiveConnection_ServiceClosed;
Windows.ApplicationModel.AppService.AppServiceConnectionStatus status = await receiveConnection.OpenAsync();
if (status == Windows.ApplicationModel.AppService.AppServiceConnectionStatus.Success)
{
// Connection established with the background task
var inputs = new ValueSet();
inputs.Add(CompanionServiceMessage.ATT_TYPE, CompanionServiceMessage.TYPE_INIT);
AppServiceResponse response = await receiveConnection.SendMessageAsync(inputs);
if ((response != null) && (response.Status == AppServiceResponseStatus.Success))
{
if ((response.Message != null) && (response.Message.ContainsKey(CompanionServiceMessage.ATT_TYPE)))
{
string s = (string)response.Message[CompanionServiceMessage.ATT_TYPE];
if (string.Equals(s, CompanionServiceMessage.TYPE_RESULT))
{
return(true);
}
}
}
}
}
return(false);
}
public virtual async System.Threading.Tasks.Task <bool> Send(CompanionDevice cd, string Message)
{
if (cd != null)
{
if (await CheckCompanionDeviceConnected(cd))
{
if (listRemoteSystems.ContainsKey(cd.Id))
{
RemoteSystemConnectionRequest rscr = new RemoteSystemConnectionRequest(listRemoteSystems[cd.Id]);
if (rscr != null)
{
using (var connection = new AppServiceConnection())
{
//Set up a new app service connection
connection.AppServiceName = AppServiceName;
connection.PackageFamilyName = PackageFamilyName;
AppServiceConnectionStatus status = await connection.OpenRemoteAsync(rscr);
if (status == AppServiceConnectionStatus.Success)
{
//Set up the inputs and send a message to the service
var inputs = new ValueSet();
inputs.Add(CompanionServiceMessage.ATT_TYPE, CompanionServiceMessage.TYPE_DATA);
inputs.Add(CompanionServiceMessage.ATT_SOURCEID, GetSourceId());
inputs.Add(CompanionServiceMessage.ATT_SOURCENAME, GetSourceName());
inputs.Add(CompanionServiceMessage.ATT_SOURCEIP, GetSourceIP());
inputs.Add(CompanionServiceMessage.ATT_SOURCEKIND, GetSourceKind());
inputs.Add(CompanionServiceMessage.ATT_MESSAGE, Message);
AppServiceResponse response = await connection.SendMessageAsync(inputs);
if ((response != null) && (response.Status == AppServiceResponseStatus.Success))
{
if ((response.Message != null) && (response.Message.ContainsKey(CompanionServiceMessage.ATT_TYPE)))
{
string s = (string)response.Message[CompanionServiceMessage.ATT_TYPE];
if (string.Equals(s, CompanionServiceMessage.TYPE_RESULT))
{
return(true);
}
}
}
}
}
}
}
}
}
return(false);
}
public override async System.Threading.Tasks.Task <bool> Initialize(CompanionDevice LocalDevice, CompanionConnectionManagerInitializeArgs InitArgs)
{
await base.Initialize(LocalDevice, InitArgs);
MulticastCompanionConnectionManagerInitializeArgs mInitArgs = InitArgs as MulticastCompanionConnectionManagerInitializeArgs;
if (mInitArgs != null)
{
MulticastIPAddress = mInitArgs.MulticastIPAddress;
MulticastUDPPort = mInitArgs.MulticastUDPPort;
UnicastUDPPort = mInitArgs.UnicastUDPPort;
UDPTransport = mInitArgs.UDPTransport;
MulticastDiscovery = mInitArgs.MulticastDiscovery;
SendInterfaceAddress = mInitArgs.SendInterfaceAddress;
if (await InitializeMulticastRecv())
{
if (await InitializeUnicastRecv())
{
if (await InitializeSend())
{
var searchDevice = listCompanionDevices.FirstOrDefault(device => string.Equals(device.Value.IPAddress, MulticastIPAddress));
if (searchDevice.Value == null)
{
CompanionDevice d = new CompanionDevice();
d.Id = "0";
d.IsRemoteSystemDevice = false;
d.IPAddress = MulticastIPAddress;
d.Name = CompanionProtocol.MulticastDeviceName;
d.Kind = CompanionProtocol.MulticastDeviceKind;
d.IsMulticast = true;
if (listCompanionDevices.ContainsKey(d.Id))
{
listCompanionDevices.Remove(d.Id);
}
listCompanionDevices.Add(d.Id, d);
OnDeviceAdded(this, d);
}
return(true);
}
}
}
}
return(false);
}
private void RemoteSystemWatcher_RemoteSystemRemoved(RemoteSystemWatcher sender, RemoteSystemRemovedEventArgs args)
{
if (listCompanionDevices != null)
{
if (listCompanionDevices.ContainsKey(args.RemoteSystemId))
{
CompanionDevice d = listCompanionDevices[args.RemoteSystemId];
OnDeviceRemoved(this, d);
listCompanionDevices.Remove(args.RemoteSystemId);
}
}
if (listRemoteSystems != null)
{
if (listRemoteSystems.ContainsKey(args.RemoteSystemId))
{
listRemoteSystems.Remove(args.RemoteSystemId);
}
}
}
protected CompanionDevice GetUniqueDeviceByName(string Name)
{
CompanionDevice device = null;
foreach (var d in listCompanionDevices)
{
if (string.Equals(d.Value.Name, Name))
{
if (device == null)
{
device = d.Value;
}
else
{
// not unique
return(null);
}
}
}
return(device);
}
public override async System.Threading.Tasks.Task <bool> Send(CompanionDevice cd, string Message)
{
if (cd != null)
{
bool bMulticast = false;
if ((!string.IsNullOrEmpty(cd.IPAddress)) && string.Equals(cd.IPAddress, MulticastIPAddress))
{
bMulticast = true;
}
if ((UDPTransport == false) && (bMulticast == false))
{
return(await base.Send(cd, Message));
}
else
{
if (!string.IsNullOrEmpty(cd.IPAddress))
{
return(await Send(cd.IPAddress, Message));
}
}
}
return(false);
}
private void RemoteSystemWatcher_RemoteSystemAdded(RemoteSystemWatcher sender, RemoteSystemAddedEventArgs args)
{
CompanionDevice d = new CompanionDevice(args.RemoteSystem.Id, true, args.RemoteSystem.DisplayName, string.Empty, args.RemoteSystem.Kind);
if ((d != null) && (listCompanionDevices != null) && (listRemoteSystems != null))
{
d.IsAvailableByProximity = args.RemoteSystem.IsAvailableByProximity;
// Anniversary issue
// d.IsAvailableBySpatialProximity = args.RemoteSystem.IsAvailableBySpatialProximity;
d.Status = CompanionDeviceStatus.Available;
if (listCompanionDevices.ContainsKey(args.RemoteSystem.Id))
{
listCompanionDevices.Remove(args.RemoteSystem.Id);
}
listCompanionDevices.Add(args.RemoteSystem.Id, d);
OnDeviceAdded(this, d);
if (listRemoteSystems.ContainsKey(args.RemoteSystem.Id))
{
listRemoteSystems.Remove(args.RemoteSystem.Id);
}
listRemoteSystems.Add(args.RemoteSystem.Id, args.RemoteSystem);
}
}
// Summary:
// Open a uri on the emote device
public virtual async System.Threading.Tasks.Task <bool> CompanionDeviceOpenUri(CompanionDevice cd, string inputUri)
{
if ((listCompanionDevices.ContainsKey(cd.Id)) && (listRemoteSystems.ContainsKey(cd.Id)))
{
RemoteSystemConnectionRequest rscr = new RemoteSystemConnectionRequest(listRemoteSystems[cd.Id]);
if (rscr != null)
{
Uri uri;
if (Uri.TryCreate(inputUri, UriKind.Absolute, out uri))
{
RemoteLaunchUriStatus launchUriStatus = await Windows.System.RemoteLauncher.LaunchUriAsync(rscr, uri);
if (launchUriStatus == RemoteLaunchUriStatus.Success)
{
listCompanionDevices[cd.Id].Status = CompanionDeviceStatus.Connected;
return(true);
}
}
}
}
return(false);
}
private async void ReceiveConnection_RequestReceived(Windows.ApplicationModel.AppService.AppServiceConnection sender, Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("ReceiveConnection_RequestReceived");
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
var messageDeferral = args.GetDeferral();
try
{
if ((args.Request != null) && (args.Request.Message != null))
{
var inputs = args.Request.Message;
if (inputs.ContainsKey(CompanionServiceMessage.ATT_TYPE))
{
string s = (string)inputs[CompanionServiceMessage.ATT_TYPE];
if (string.Equals(s, CompanionServiceMessage.TYPE_DATA))
{
if ((inputs.ContainsKey(CompanionServiceMessage.ATT_SOURCEID)) &&
(inputs.ContainsKey(CompanionServiceMessage.ATT_SOURCEID)) &&
(inputs.ContainsKey(CompanionServiceMessage.ATT_SOURCEIP)) &&
(inputs.ContainsKey(CompanionServiceMessage.ATT_SOURCEKIND)) &&
(inputs.ContainsKey(CompanionServiceMessage.ATT_SOURCENAME)) &&
(inputs.ContainsKey(CompanionServiceMessage.ATT_MESSAGE)))
{
string id = (string)inputs[CompanionServiceMessage.ATT_SOURCEID];
string name = (string)inputs[CompanionServiceMessage.ATT_SOURCENAME];
string ip = (string)inputs[CompanionServiceMessage.ATT_SOURCEIP];
string kind = (string)inputs[CompanionServiceMessage.ATT_SOURCEKIND];
string message = (string)inputs[CompanionServiceMessage.ATT_MESSAGE];
CompanionDevice d = new CompanionDevice(id, false, name, ip, kind);
if (!string.IsNullOrEmpty(ip))
{
CompanionDevice a = GetUniqueDeviceByName(name);
if (a != null)
{
if (!string.Equals(a.IPAddress, ip))
{
a.IPAddress = ip;
listCompanionDevices.Remove(a.Id);
listCompanionDevices.Add(id, a);
OnDeviceUpdated(this, a);
}
}
}
if (MessageReceived != null)
{
MessageReceived(d, message);
}
}
}
else if (string.Equals(s, CompanionServiceMessage.TYPE_INIT))
{
// Background task started
}
}
}
}
finally
{
//Complete the message deferral so the platform knows we're done responding
messageDeferral.Complete();
}
});
}
async void UDPMulticastMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments)
{
try
{
uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength;
string message = eventArguments.GetDataReader().ReadString(stringLength);
string Command = CompanionProtocol.GetCommandFromMessage(message);
Dictionary <string, string> Parameters = CompanionProtocol.GetParametersFromMessage(message);
CompanionDevice d = GetCompanionDeviceFromParameters(Parameters);
System.Diagnostics.Debug.WriteLine("Received command: " + message);
if (string.Equals(Command, CompanionProtocol.commandPingResponse))
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
if (d != null)
{
var searchDevice = listCompanionDevices.FirstOrDefault(device => string.Equals(device.Value.Name, d.Name));
if (searchDevice.Value == null)
{
// Add Device
d.Status = CompanionDeviceStatus.Connected;
if (string.IsNullOrEmpty(d.Id))
{
d.Id = Guid.NewGuid().ToString();
}
if (listCompanionDevices.ContainsKey(d.Id))
{
listCompanionDevices.Remove(d.Id);
}
listCompanionDevices.Add(d.Id, d);
OnDeviceAdded(this, d);
}
else
{
if (!string.Equals(d.IPAddress, searchDevice.Value.IPAddress))
{
d.Id = searchDevice.Value.Id;
d.Status = CompanionDeviceStatus.Connected;
listCompanionDevices.Remove(d.Id);
listCompanionDevices.Add(d.Id, d);
// Update device
OnDeviceUpdated(this, d);
}
}
}
});
}
else if (string.Equals(Command, CompanionProtocol.commandPing))
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
if (d != null)
{
/*
* var searchDevice = listCompanionDevices.FirstOrDefault(device => string.Equals(device.Value.Name, d.Name) );
* if (searchDevice.Value == null)
* {
* d.Status = CompanionDeviceStatus.Connected;
* listCompanionDevices.Add(d.Id, d);
* if (CompanionDeviceAdded != null)
* CompanionDeviceAdded(this, d);
* }
* else
* {
* if ((!string.Equals(d.Id, searchDevice.Value.Id)) ||
* (!string.Equals(d.IPAddress, searchDevice.Value.IPAddress)))
* {
* d.Id = searchDevice.Value.Id;
* d.Status = CompanionDeviceStatus.Connected;
* listCompanionDevices.Remove(d.Id);
* listCompanionDevices.Add(d.Id, d);
* // Update device
* if (CompanionDeviceUpdated != null)
* CompanionDeviceUpdated(this, d);
* }
* }
*/
Dictionary <string, string> parameters = new Dictionary <string, string>();
if (parameters != null)
{
parameters.Add(CompanionProtocol.parameterID, LocalCompanionDevice.Id);
parameters.Add(CompanionProtocol.parameterIPAddress, LocalCompanionDevice.IPAddress);
parameters.Add(CompanionProtocol.parameterKind, LocalCompanionDevice.Kind);
parameters.Add(CompanionProtocol.parameterName, LocalCompanionDevice.Name);
string m = CompanionProtocol.CreateCommand(CompanionProtocol.commandPingResponse, parameters);
await Send(d.IPAddress, m);
}
}
});
}
else
{
// Forward the Message
if (MessageReceived != null)
{
MessageReceived(d, message);
}
}
}
catch (Exception exception)
{
System.Diagnostics.Debug.WriteLine("Exception on receiving UDP packets: " + exception.Message);
SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult);
if (socketError == SocketErrorStatus.ConnectionResetByPeer)
{
}
else if (socketError != SocketErrorStatus.Unknown)
{
}
}
}
