private async Task<string> SendMessageAsync(ValueSet message)
{
using (var connection = new AppServiceConnection())
{
connection.AppServiceName = BookServiceName;
connection.PackageFamilyName = BooksPackageName;
AppServiceConnectionStatus status = await connection.OpenAsync();
if (status == AppServiceConnectionStatus.Success)
{
AppServiceResponse response = await connection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success && response.Message.ContainsKey("result"))
{
string result = response.Message["result"].ToString();
return result;
}
else
{
await ShowServiceErrorAsync(response.Status);
}
}
else
{
await ShowConnectionErrorAsync(status);
}
return string.Empty;
}
}
/// <summary>
/// Creates the app service connection
/// </summary>
static async void ThreadProc()
{
connection = new AppServiceConnection();
connection.AppServiceName = "CommunicationService";
connection.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
connection.RequestReceived += Connection_RequestReceived;
AppServiceConnectionStatus status = await connection.OpenAsync();
switch (status)
{
case AppServiceConnectionStatus.Success:
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Connection established - waiting for requests");
Console.WriteLine();
break;
case AppServiceConnectionStatus.AppNotInstalled:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The app AppServicesProvider is not installed.");
return;
case AppServiceConnectionStatus.AppUnavailable:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The app AppServicesProvider is not available.");
return;
case AppServiceConnectionStatus.AppServiceUnavailable:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Format("The app AppServicesProvider is installed but it does not provide the app service {0}.", connection.AppServiceName));
return;
case AppServiceConnectionStatus.Unknown:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Format("An unkown error occurred while we were trying to open an AppServiceConnection."));
return;
}
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
switch (command)
{
case "CalcSum":
{
var messageDeferral = args.GetDeferral();
int value1 = (int)message["Value1"];
int value2 = (int)message["Value2"];
//Set a result to return to the caller
int result = value1 + value2;
var returnMessage = new ValueSet();
returnMessage.Add("Result", result);
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
}
case "Quit":
{
//Service was asked to quit. Give us service deferral
//so platform can terminate the background task
_serviceDeferral.Complete();
break;
}
}
}
private async System.Threading.Tasks.Task EnsureConnectionToService()
{
if (this.connection == null)
{
connection = new AppServiceConnection();
// See the appx manifest of the AppServicesDemp app for this value
connection.AppServiceName = "microsoftDX-appservicesdemo";
// Use the Windows.ApplicationModel.Package.Current.Id.FamilyName API in the
// provider app to get this value
connection.PackageFamilyName = "82a987d5-4e4f-4cb4-bb4d-700ede1534ba_nsf9e2fmhb1sj";
AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();
if (connectionStatus == AppServiceConnectionStatus.Success)
{
connection.ServiceClosed += OnServiceClosed;
//connection.RequestReceived += OnRequestReceived;
}
else
{
//Drive the user to store to install the app that provides
//the app service
}
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var reqDeferral = args.GetDeferral();
var message = args.Request.Message;
var result = new ValueSet();
if (args.Request.Message.ContainsKey("service"))
{
var serviceName = message["service"] as string;
if (serviceName.Equals("add", StringComparison.OrdinalIgnoreCase))
{
if (message.ContainsKey("a") && message.ContainsKey("b"))
{
result.Add("result", Add((int)message["a"], (int)message["b"]));
}
}
else if (serviceName.Equals("sub", StringComparison.OrdinalIgnoreCase))
{
if (message.ContainsKey("a") && message.ContainsKey("b"))
{
result.Add("result", Sub((int)message["a"], (int)message["b"]));
}
}
else
{
result.Add("result", 0);
}
}
await args.Request.SendResponseAsync(result);
reqDeferral.Complete();
}
public AzureIoTHubConnection(AppServiceConnection connection)
{
_appServiceConnection = connection;
deviceClient = DeviceClient.CreateFromConnectionString(DeviceConnectionString);
_appServiceConnection.RequestReceived += OnRequestReceived;
}
public WebSocketServer(AppServiceConnection connection)
{
_appServiceConnection = connection;
_appServiceConnection.RequestReceived += OnRequestReceived;
_portMapping = new IdHelper(5);
}
private async System.Threading.Tasks.Task EnsureConnectionToSynonymsService()
{
if (this.synonymsServiceConnection == null)
{
synonymsServiceConnection = new AppServiceConnection();
// See the appx manifest of the AppServicesDemp app for this value
synonymsServiceConnection.AppServiceName = "MicrosoftDX-SynonymsService";
// Use the Windows.ApplicationModel.Package.Current.Id.FamilyName API in the
// provider app to get this value
synonymsServiceConnection.PackageFamilyName = "82a987d5-4e4f-4cb4-bb4d-700ede1534ba_nsf9e2fmhb1sj";
AppServiceConnectionStatus connectionStatus = await synonymsServiceConnection.OpenAsync();
if (connectionStatus == AppServiceConnectionStatus.Success)
{
synonymsServiceConnection.ServiceClosed += (s, serviceClosedEventArgs) =>
{
if (ServiceClosed != null)
{
ServiceClosed(this, serviceClosedEventArgs);
}
};
}
else
{
//Drive the user to store to install the app that provides
//the app service
throw new NotImplementedException("Service not installed on this device");
}
}
}
public async Task<ValueSet> MakeUWPCommandCall(string commandCall, string serviceName) {
if (AppExtension == null) return null;
using (var connection = new AppServiceConnection())
{
connection.AppServiceName = serviceName;
connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;
var status = await connection.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
Debug.WriteLine("Failed app service connection");
}
else
{
var request = new ValueSet();
request.Add("Command", commandCall);
AppServiceResponse response = await connection.SendMessageAsync(request);
if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
{
var message = response.Message as ValueSet;
if (message != null && message.Count > 0) {
message.Add(new KeyValuePair<string, object>("AppExtensionDisplayName", AppExtension.AppInfo.DisplayInfo.DisplayName));
}
return (message!=null && message.Count>0)? message: null;
}
}
}
return null;
}
private async void CallService_Click(object sender, RoutedEventArgs e)
{
var connection = new AppServiceConnection();
connection.PackageFamilyName = "0df93276-6bbb-46fa-96b7-ec223e226505_cb1hhkscw5m06"; // Windows.ApplicationModel.Package.Current.Id.FamilyName;
connection.AppServiceName = "CalculatorService";
var status = await connection.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
var dialog = new MessageDialog("Sorry, I can't connect to the service right now :S");
await dialog.ShowAsync();
return;
}
var message = new ValueSet();
message.Add("service", OperatorCombo.Items[OperatorCombo.SelectedIndex]);
message.Add("a", Convert.ToInt32(ValueABox.Text));
message.Add("b", Convert.ToInt32(ValueBBox.Text));
AppServiceResponse response = await connection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success)
{
if (response.Message.ContainsKey("result"))
{
ResultBlock.Text = response.Message["result"] as string;
}
}
else
{
var dialog = new MessageDialog(string.Format("Opps, I just get an error :S ({0})", response.Status));
await dialog.ShowAsync();
}
}
public async Task<IEnumerable<Beer>> GetBeersByFilter(string filter)
{
AppServiceConnection connection = new AppServiceConnection();
connection.AppServiceName = "PlainConcepts-appservicesdemo";
connection.PackageFamilyName = "cff6d46b-5839-4bb7-a1f2-e59246de63b3_cb1hhkscw5m06";
AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();
if (connectionStatus == AppServiceConnectionStatus.Success)
{
//Send data to the service
var message = new ValueSet();
message.Add("Command", "GetBeersByFilter");
message.Add("Filter", filter);
//Send message and wait for response
AppServiceResponse response = await connection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success)
{
var resultJson = (string)response.Message["Result"];
var list = JsonConvert.DeserializeObject<IEnumerable<Beer>>(resultJson);
return list;
}
}
else
{
//Drive the user to store to install the app that provides the app service
new MessageDialog("Service not installed").ShowAsync();
}
return null;
}
private async void OnMessageReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string newState = message["State"] as string;
switch (newState)
{
case "On":
{
await Dispatcher.RunAsync(
CoreDispatcherPriority.High,
() =>
{
TurnOnLED();
});
break;
}
case "Off":
{
await Dispatcher.RunAsync(
CoreDispatcherPriority.High,
() =>
{
TurnOffLED();
});
break;
}
case "Unspecified":
default:
{
// Do nothing
break;
}
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
Loading.IsActive = true;
AppServiceConnection connection = new AppServiceConnection();
connection.PackageFamilyName = Package.Current.Id.FamilyName;
connection.AppServiceName = "FeedParser";
var status = await connection.OpenAsync();
if (status == AppServiceConnectionStatus.Success)
{
ValueSet data = new ValueSet();
data.Add("FeedUrl", "http://blog.qmatteoq.com/feed/");
var response = await connection.SendMessageAsync(data);
if (response.Status == AppServiceResponseStatus.Success)
{
string items = response.Message["FeedItems"].ToString();
var result = JsonConvert.DeserializeObject<List<FeedItem>>(items);
News.ItemsSource = result;
}
}
Loading.IsActive = false;
}
private async Task LaunchAppService(string cmd)
{
var connection = new AppServiceConnection
{
AppServiceName = "uwpdeepdive-appservice",
PackageFamilyName = "11fc3805-6c54-417b-916c-a4f6e89876b2_2eqywga5gg4gm"
};
var appServiceConnectionStatus = await connection.OpenAsync();
if (appServiceConnectionStatus != AppServiceConnectionStatus.Success)
{
_resultsTextBox.Text = appServiceConnectionStatus.ToString();
return;
}
var msg = new ValueSet {["cmd"] = cmd};
var appServiceResponse = await connection.SendMessageAsync(msg);
if (appServiceResponse.Status != AppServiceResponseStatus.Success)
{
_resultsTextBox.Text = appServiceResponse.Status.ToString();
return;
}
var time = appServiceResponse.Message[cmd] as string;
_resultsTextBox.Text = time ?? "";
//note - communication is two-way! can send/receive as needed
//connection.RequestReceived += delegate(
// AppServiceConnection sender, AppServiceRequestReceivedEventArgs args) { /* ... */ };
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var msgDef = args.GetDeferral();
var msg = args.Request.Message;
var returnData = new ValueSet();
var command = msg["Command"] as string;
switch (command) {
case "UI":
returnData.Add("sketch-test", "X.Extension.ThirdParty.Backgrounds.UI.Test");
returnData.Add("sketch-home", "X.Extension.ThirdParty.Backgrounds.UI.Home");
break;
case "RandomBackground":
Random rnd = new Random();
returnData.Add("filename", $"bkg0{rnd.Next(1, 5)}.jpg");
break;
case "Spritesheet":
returnData.Add("spritesheet-img", "bkg-spritesheet.jpg");
returnData.Add("spritesheet-xml", "bkg-spritesheet.xml");
break;
}
await args.Request.SendResponseAsync(returnData);
msgDef.Complete();
}
public RestServer(int serverPort, string serviceConnection)
{
listener = new StreamSocketListener();
port = serverPort;
appServiceConnection = new AppServiceConnection() { AppServiceName = serviceConnection };
listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);
}
public RestServer(int serverPort, AppServiceConnection connection)
{
listener = new StreamSocketListener();
port = serverPort;
appServiceConnection = connection;
listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);
}
private async void SetupAppService()
{
// find the installed application(s) that expose the app service PerimeterBreachService
var listing = await AppServiceCatalog.FindAppServiceProvidersAsync("PerimeterBreachService");
var packageName = "";
// there may be cases where other applications could expose the same App Service Name, in our case
// we only have the one
if (listing.Count == 1)
{
packageName = listing[0].PackageFamilyName;
}
_perimeterBreachService = new AppServiceConnection();
_perimeterBreachService.AppServiceName = "PerimeterBreachService";
_perimeterBreachService.PackageFamilyName = packageName;
//open app service connection
var status = await _perimeterBreachService.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
//something went wrong
txtStatus.Text = "Could not connect to the App Service: " + status.ToString();
}
else
{
//add handler to receive app service messages (Perimiter messages)
_perimeterBreachService.RequestReceived += PerimeterBreachService_RequestReceived;
}
}
async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
//Get a deferral so we can use an awaitable API to respond to the message
var messageDeferral = args.GetDeferral();
try
{
var input = args.Request.Message;
int minValue = (int)input["minvalue"];
int maxValue = (int)input["maxvalue"];
//Create the response
var result = new ValueSet();
result.Add("result", randomNumberGenerator.Next(minValue, maxValue));
//Send the response
await args.Request.SendResponseAsync(result);
}
finally
{
//Complete the message deferral so the platform knows we're done responding
messageDeferral.Complete();
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// if you are doing anything awaitable, you need to get a deferral
var requestDeferral = args.GetDeferral();
var returnMessage = new ValueSet();
try
{
//obtain and react to the command passed in by the client
var message = args.Request.Message["Request"] as string;
switch (message)
{
case "Turn LED On":
_ledPin.Write(GpioPinValue.High);
break;
case "Turn LED Off":
_ledPin.Write(GpioPinValue.Low);
break;
}
returnMessage.Add("Response", "OK");
}
catch (Exception ex)
{
returnMessage.Add("Response", "Failed: " + ex.Message);
}
await args.Request.SendResponseAsync(returnMessage);
//let the OS know that the action is complete
requestDeferral.Complete();
}
//TemperatureSensors tempSensors;
public void Run(IBackgroundTaskInstance taskInstance)
{
//if (!_started)
//{
// tempSensors = new TemperatureSensors();
// tempSensors.InitSensors();
// _started = true;
//}
// Associate a cancellation handler with the background task.
taskInstance.Canceled += TaskInstance_Canceled;
// Get the deferral object from the task instance
serviceDeferral = taskInstance.GetDeferral();
var appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (appService != null && appService.Name == "App2AppComService")
{
appServiceConnection = appService.AppServiceConnection;
appServiceConnection.RequestReceived += AppServiceConnection_RequestReceived; ;
}
// just run init, maybe don't need the above...
Initialize();
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
switch (command)
{
case "Initialize":
var messageDeferral = args.GetDeferral();
//Set a result to return to the caller
var returnMessage = new ValueSet();
HttpServer server = new HttpServer(8000, appServiceConnection);
IAsyncAction asyncAction = Windows.System.Threading.ThreadPool.RunAsync(
(workItem) =>
{
server.StartServer();
});
returnMessage.Add("Status", "Success");
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
case "Quit":
//Service was asked to quit. Give us service deferral
//so platform can terminate the background task
serviceDeferral.Complete();
break;
}
}
private async void InitializeService()
{
_appServiceConnection = new AppServiceConnection
{
PackageFamilyName = "ConnectionService-uwp_5gyrq6psz227t",
AppServiceName = "App2AppComService"
};
// Send a initialize request
var res = await _appServiceConnection.OpenAsync();
if (res == AppServiceConnectionStatus.Success)
{
var message = new ValueSet {{"Command", "Connect"}};
var response = await _appServiceConnection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success)
{
InitializeSerialBridge();
//InitializeBluetoothBridge();
_appServiceConnection.RequestReceived += _serialBridge.OnCommandRecived;
//_appServiceConnection.RequestReceived += _bluetoothBridge.OnCommandRecived;
//_appServiceConnection.RequestReceived += _appServiceConnection_RequestReceived;
}
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral deferral = args.GetDeferral();
try
{
ValueSet message = args.Request.Message;
ValueSet result = null;
switch (message["command"].ToString())
{
case "GET":
result = GetBooks();
break;
case "POST":
result = AddBook(message["book"].ToString());
break;
default:
break;
}
await args.Request.SendResponseAsync(result);
}
finally
{
deferral.Complete();
}
}
public async Task<IEnumerable<FeedItem>> GetNewsAsync(string url)
{
AppServiceConnection connection = new AppServiceConnection();
connection.PackageFamilyName = "637bc306-acb1-4e73-bbe0-70ecc919ca1c_e8f4dqfvn1be6";
connection.AppServiceName = "FeedParser";
var status = await connection.OpenAsync();
if (status == AppServiceConnectionStatus.Success)
{
ValueSet data = new ValueSet();
data.Add("FeedUrl", url);
var response = await connection.SendMessageAsync(data);
if (response.Status == AppServiceResponseStatus.Success)
{
string items = response.Message["FeedItems"].ToString();
var result = JsonConvert.DeserializeObject<List<FeedItem>>(items);
return result;
}
else
{
return null;
}
}
else
{
return null;
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var response = new ValueSet();
bool stop = false;
try
{
var request = args.Request;
var message = request.Message;
if (message.ContainsKey(BackgroundOperation.NewBackgroundRequest))
{
switch ((BackgroundRequest)message[BackgroundOperation.NewBackgroundRequest])
{
default:
stop = true;
break;
}
}
}
finally
{
if (stop)
{
_deferral.Complete();
}
}
}
private async void InitializeAppSvc()
{
string WebServerStatus = "PoolWebServer failed to start. AppServiceConnectionStatus was not successful.";
// Initialize the AppServiceConnection
appServiceConnection = new AppServiceConnection();
appServiceConnection.PackageFamilyName = "PoolWebServer_hz258y3tkez3a";
appServiceConnection.AppServiceName = "App2AppComService";
// Send a initialize request
var res = await appServiceConnection.OpenAsync();
if (res == AppServiceConnectionStatus.Success)
{
var message = new ValueSet();
message.Add("Command", "Initialize");
var response = await appServiceConnection.SendMessageAsync(message);
if (response.Status != AppServiceResponseStatus.Success)
{
WebServerStatus = "PoolWebServer failed to start.";
throw new Exception("Failed to send message");
}
appServiceConnection.RequestReceived += OnMessageReceived;
WebServerStatus = "PoolWebServer started.";
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
txtWebServerStatus.Text = WebServerStatus;
});
}
private async void CallService_Click(object sender, RoutedEventArgs e)
{
var connection = new AppServiceConnection();
connection.PackageFamilyName = "041cdcf9-8ef3-40e4-85e2-8f3de5e06155_ncrzdc1cmma1g"; // Windows.ApplicationModel.Package.Current.Id.FamilyName;
connection.AppServiceName = "CalculatorService";
var status = await connection.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
var dialog = new MessageDialog("Sorry, I can't connect to the service right now :S");
await dialog.ShowAsync();
return;
}
var message = new ValueSet();
message.Add("service", (OperatorCombo.SelectedValue as ComboBoxItem).Content);
message.Add("a", Convert.ToInt32(ValueABox.Text));
message.Add("b", Convert.ToInt32(ValueBBox.Text));
AppServiceResponse response = await connection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success)
{
if (response.Message.ContainsKey("result"))
{
ResultBlock.Text = response.Message["result"].ToString();
}
}
else
{
var dialog = new MessageDialog(string.Format("Opps, I just get an error :S ({0})", response.Status));
await dialog.ShowAsync();
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var lDeferral = args.GetDeferral();
try
{
var message = args.Request.Message;
if(message.ContainsKey("MessageType") && message.ContainsKey("Message"))
{
var type = message["MessageType"] as String;
var mes = message["Message"] as String;
if(type != null && mes != null)
{
using(var lh = new LoggingHelper())
{
var result = lh.LogEntry(type, mes);
var vs = new ValueSet();
vs["result"] = result;
await args.Request.SendResponseAsync(vs);
}
}
}
}
catch { }
lDeferral.Complete();
}
private async void GetEmployeeById(object sender, RoutedEventArgs e)
{
appServiceConnection = new AppServiceConnection
{
AppServiceName = "EmployeeLookupService",
PackageFamilyName = "3598a822-2b34-44cc-9a20-421137c7511f_4frctqp64dy5c"
};
var status = await appServiceConnection.OpenAsync();
switch (status)
{
case AppServiceConnectionStatus.AppNotInstalled:
await LogError("The EmployeeLookup application is not installed. Please install it and try again.");
return;
case AppServiceConnectionStatus.AppServiceUnavailable:
await LogError("The EmployeeLookup application does not have the available feature");
return;
case AppServiceConnectionStatus.AppUnavailable:
await LogError("The package for the app service to which a connection was attempted is unavailable.");
return;
case AppServiceConnectionStatus.Unknown:
await LogError("Unknown Error.");
return;
}
var items = this.EmployeeId.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
var message = new ValueSet();
for (int i = 0; i < items.Length; i++)
{
message.Add(i.ToString(), items[i]);
}
var response = await appServiceConnection.SendMessageAsync(message);
switch (response.Status)
{
case AppServiceResponseStatus.ResourceLimitsExceeded:
await LogError("Insufficient resources. The app service has been shut down.");
return;
case AppServiceResponseStatus.Failure:
await LogError("Failed to receive response.");
return;
case AppServiceResponseStatus.Unknown:
await LogError("Unknown error.");
return;
}
foreach (var item in response.Message)
{
this.Items.Add(new Employee
{
Id = item.Key,
Name = item.Value.ToString()
});
}
}
public SystrayApplicationContext()
{
var sendMessageMenuItem = new MenuItem("Send Message", SendMessageToApp);
var launchMenuItem = new MenuItem("Launch", LaunchApp);
var exitMenuItem = new MenuItem("Exit", ExitApp);
launchMenuItem.DefaultItem = true;
var notifyIcon = new NotifyIcon();
notifyIcon.DoubleClick += LaunchApp;
notifyIcon.Icon = Properties.Resources.IconMaPhone;
notifyIcon.ContextMenu = new ContextMenu(new[]
{
sendMessageMenuItem, launchMenuItem, exitMenuItem
});
notifyIcon.Visible = true;
_appServiceConnection = CreateAppServiceConnection();
}
public override ValueSet OnRequest(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
string versionID = args.Request.Message["version"].ToString();
KMCCC.Launcher.Version ver = Program.Launcher.Core.GetVersion(versionID);
if (ver == null)
{
return(null);
}
ValueSet ret = new ValueSet();
ret["client"] = ver.Downloads.Client.Url;
ret["client-sha1"] = ver.Downloads.Client.SHA1;
ret["server"] = ver.Downloads.Server.Url;
ret["server-sha1"] = ver.Downloads.Server.SHA1;
return(ret);
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var msgDef = args.GetDeferral();
var msg = args.Request.Message;
var returnData = new ValueSet();
var command = msg["Command"] as string;
switch (command)
{
case "UI":
returnData.Add("sketch-test", "X.Extension.ThirdParty.AWS.UI.Test");
returnData.Add("sketch-home", "X.Extension.ThirdParty.AWS.UI.Home");
break;
}
await args.Request.SendResponseAsync(returnData);
msgDef.Complete();
}
private async void InitializeAppServiceConnection()
{
Connection = new AppServiceConnection();
Connection.AppServiceName = "FilesInteropService";
Connection.PackageFamilyName = Package.Current.Id.FamilyName;
Connection.RequestReceived += Connection_RequestReceived;
Connection.ServiceClosed += Connection_ServiceClosed;
AppServiceConnectionStatus status = await Connection.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
// TODO: error handling
Connection.Dispose();
Connection = null;
}
// Launch fulltrust process
await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
var pkgFamilyName = Package.Current.Id.FamilyName;
System.Diagnostics.Debug.WriteLine(pkgFamilyName);
//Take a service deferral so the service isn't terminated
serviceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += OnTaskCanceled;
if (taskInstance.TriggerDetails != null)
{
var details = taskInstance.TriggerDetails as AppServiceTriggerDetails;
connection = details.AppServiceConnection;
//Listen for incoming app service requests
connection.RequestReceived += OnRequestReceived;
}
}
private async void AppServiceRequestHandler(AppServiceConnection connection, AppServiceRequestReceivedEventArgs args)
{
TwinCollection collection = null;
foreach (var pair in args.Request.Message)
{
if (pair.Key.StartsWith("Config"))
{
if (collection == null)
{
collection = new TwinCollection();
}
collection[pair.Key] = pair.Value;
}
}
if (collection != null)
{
await _client.UpdateReportedPropertiesAsync(collection);
}
}
public static async Task <VoiceViewModel> StartNewAsync(DiscordChannel channel)
{
var model = new VoiceViewModel();
var service = new AppServiceConnection
{
AppServiceName = "com.wankerr.Unicord.Voice",
PackageFamilyName = Package.Current.Id.FamilyName
};
var status = await service.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
throw new Exception("Whoops??");
}
var resp = await service.SendMessageAsync(new ValueSet()
{
["request"] = "connect",
["token"] = App.Discord.Configuration.Token,
["server"] = channel.GuildId.ToString(),
["channel"] = channel.Id.ToString()
});
if (resp.Status == AppServiceResponseStatus.Success)
{
var connected = (bool)resp.Message["connected"];
if (connected)
{
service.RequestReceived += model.RequestRecieved;
return(model);
}
else
{
throw new Exception(resp.Message["error"] as string);
}
}
return(null);
}
private async void Track_Click(object sender, RoutedEventArgs e)
{
if (serviceConnection == null)
{
serviceConnection = new AppServiceConnection();
serviceConnection.AppServiceName = "TrackingServiceEndpoint";
serviceConnection.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
var status = await serviceConnection.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
this.StatusLog.Items.Add("Failed to open connection: " + status.ToString());
return;
}
this.StatusLog.Items.Add("Connection open!");
}
var message = new ValueSet();
message.Add("PackageID", "12345");
this.StatusLog.Items.Add("Sending a message");
AppServiceResponse response = await serviceConnection.SendMessageAsync(message);
this.StatusLog.Items.Add("Message sent. Response received (" + response.Status + ")");
if (response.Status == AppServiceResponseStatus.Success)
{
if (response.Message.Keys.Count() > 0)
{
string key = response.Message.Keys.First();
this.StatusLog.Items.Add("Status: " + response.Message[key] as string);
}
}
else
{
this.StatusLog.Items.Add("Message send failed!");
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// Get a deferral because we use an awaitable API below to respond to the message
// and we don't want this call to get cancelled while we are waiting.
var messageDeferral = args.GetDeferral();
// The fulltrust process signaled that something in the recycle bin folder has changed
if (args.Request.Message.ContainsKey("FileSystem"))
{
var folderPath = (string)args.Request.Message["FileSystem"];
var itemPath = (string)args.Request.Message["Path"];
var changeType = (string)args.Request.Message["Type"];
var newItem = JsonConvert.DeserializeObject <ShellFileItem>(args.Request.Message.Get("Item", ""));
Debug.WriteLine("{0}: {1}", folderPath, changeType);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// If we are currently displaying the reycle bin lets refresh the items
if (CurrentInstance.FilesystemViewModel?.CurrentFolder?.ItemPath == folderPath)
{
switch (changeType)
{
case "Created":
CurrentInstance.FilesystemViewModel.AddFileOrFolderFromShellFile(newItem);
break;
case "Deleted":
CurrentInstance.FilesystemViewModel.RemoveFileOrFolder(itemPath);
break;
default:
CurrentInstance.FilesystemViewModel.RefreshItems();
break;
}
}
});
}
// Complete the deferral so that the platform knows that we're done responding to the app service call.
// Note for error handling: this must be called even if SendResponseAsync() throws an exception.
messageDeferral.Complete();
}
async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
//Get a deferral so we can use an awaitable API to respond to the message
var messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
ValueSet returnData = new ValueSet();
try
{
string packageFamilyName = message["PackageFamilyName"] as string;
string packageLocation = message["PackageLocation"] as string;
ApplicationData.Current.LocalSettings.Values["PackageLocation"] = packageLocation;
ApplicationData.Current.LocalSettings.Values["PackageStatus"] = "start update";
PackageManager packagemanager = new PackageManager();
var x =
await
packagemanager.UpdatePackageAsync(new Uri(packageLocation), null,
DeploymentOptions.ForceApplicationShutdown);
ApplicationData.Current.LocalSettings.Values["PackageStatus"] = x.ErrorText + "," +
x.ActivityId.ToString();
//Don't need to send anything back since the app is killed during updating but you might want this if you ask to update another app instead
//of yourself.
// returnData.Add("Status", "OK");
// await args.Request.SendResponseAsync(returnData);
}
catch (Exception e)
{
ApplicationData.Current.LocalSettings.Values["PackageStatus"] = e.Message;
Debug.WriteLine(e.Message);
//
}
finally
{
//Complete the message deferral so the platform knows we're done responding
messageDeferral.Complete();
}
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
switch (command)
{
case "Initialize":
{
//Sensors.InitSensors();
//Devices.InitDevices();
var messageDeferral = args.GetDeferral();
Initialize();
////Define a new instance of our HTTPServer on Port 8888
//HttpServer server = new HttpServer(8888, appServiceConnection);
//IAsyncAction asyncAction = Windows.System.Threading.ThreadPool.RunAsync(
// (workItem) =>
// { //Start the Sever
// server.StartServer();
// });
//Set a result to return to the caller
var returnMessage = new ValueSet();
//Respond back to PoolWebService with a Status of Success
returnMessage.Add("Status", "Success");
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
}
case "Quit":
{
//Service was asked to quit. Give us service deferral
//so platform can terminate the background task
serviceDeferral.Complete();
break;
}
}
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
try
{
// Determine which of those must be run on main thread?
// Or do we run them all on the main thread to be on the safe side?
var message = args.Request.Message;
string action = (string)message["ACTION"];
switch (action)
{
case ConnectionHelper.VALUE_SLEEP:
OnSuspendRequested();
break;
case ConnectionHelper.VALUE_SLEEP_ALT:
OnMonitorStandbyRequested();
break;
case ConnectionHelper.VALUE_DISPLAY_OFF:
OnMonitorOffRequested();
break;
case ConnectionHelper.VALUE_HOTKEY_SETTINGS:
OnHotkeySettingsChanged();
break;
default:
break;
}
var result = new ValueSet();
result.Add(ConnectionHelper.KEY_RESULT, ConnectionHelper.VALUE_OK);
await args.Request.SendResponseAsync(result);
}
finally
{
deferral.Complete();
}
}
protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
base.OnBackgroundActivated(args);
IBackgroundTaskInstance taskInstance = args.TaskInstance;
AppServiceTriggerDetails appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (appService?.Name == "com.roamit.notificationservice")
{
notificationAppServiceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled -= OnNotificationAppServicesCanceled;
taskInstance.Canceled += OnNotificationAppServicesCanceled;
notificationAppServiceConnection = appService.AppServiceConnection;
notificationAppServiceConnection.RequestReceived -= OnNotificationAppServiceRequestReceived;
notificationAppServiceConnection.RequestReceived += OnNotificationAppServiceRequestReceived;
notificationAppServiceConnection.ServiceClosed -= NotificationAppServiceConnection_ServiceClosed;
notificationAppServiceConnection.ServiceClosed += NotificationAppServiceConnection_ServiceClosed;
}
else if (appService?.Name == "com.roamit.messagecarrierservice")
{
messageCarrierAppServiceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled -= OnMessageCarrierAppServicesCanceled;
taskInstance.Canceled += OnMessageCarrierAppServicesCanceled;
messageCarrierAppServiceConnection = appService.AppServiceConnection;
messageCarrierAppServiceConnection.RequestReceived -= OnMessageCarrierAppServiceRequestReceived;
messageCarrierAppServiceConnection.RequestReceived += OnMessageCarrierAppServiceRequestReceived;
messageCarrierAppServiceConnection.ServiceClosed -= MessageCarrierAppServiceConnection_ServiceClosed;
messageCarrierAppServiceConnection.ServiceClosed += MessageCarrierAppServiceConnection_ServiceClosed;
}
else if (appService?.Name == "com.roamit.pcservice")
{
pcAppServiceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled -= OnPCAppServicesCanceled;
taskInstance.Canceled += OnPCAppServicesCanceled;
pcAppServiceConnection = appService.AppServiceConnection;
pcAppServiceConnection.RequestReceived -= OnPCAppServiceRequestReceived;
pcAppServiceConnection.RequestReceived += OnPCAppServiceRequestReceived;
pcAppServiceConnection.ServiceClosed -= PCAppServiceConnection_ServiceClosed;
pcAppServiceConnection.ServiceClosed += PCAppServiceConnection_ServiceClosed;
}
}
private async Task StartAppService()
{
if (this.appService == null)
{
this.appService = new AppServiceConnection();
// Here, we use the app service name defined in the app service
// provider's Package.appxmanifest file in the <Extension> section.
this.appService.AppServiceName = "InProcessAppService";
// Use Windows.ApplicationModel.Package.Current.Id.FamilyName
// within the app service provider to get this value.
this.appService.PackageFamilyName = "30812FreistLi.HoloDomino_33rssfepyhexc";
var status = await this.appService.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
Debug.WriteLine("Failed to create");
return;
}
}
var message = new ValueSet();
message.Add("Request", "StartAnimator");
AppServiceResponse response = await this.appService.SendMessageAsync(message);
string result = "";
if (response.Status == AppServiceResponseStatus.Success)
{
// Get the data that the service sent to us.
if (response.Message["Response"] as string == "OK")
{
result = response.Message["StatusCode"] as string;
}
}
message.Clear();
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var Deferral = args.GetDeferral();
try
{
if (SpinWait.SpinUntil(() => Connections.Count == 2, 8000))
{
AppServiceConnection AnotherConnection = Connections.FirstOrDefault((Con) => Con != sender);
AppServiceResponse AnotherRespose = await AnotherConnection.SendMessageAsync(args.Request.Message);
if (AnotherRespose.Status == AppServiceResponseStatus.Success)
{
await args.Request.SendResponseAsync(AnotherRespose.Message);
}
}
else
{
ValueSet Value = new ValueSet
{
{ "Error", "Another device failed to make a peer-to-peer connection within the specified time" }
};
await args.Request.SendResponseAsync(Value);
}
}
catch
{
ValueSet Value = new ValueSet
{
{ "Error", "Some exceptions were thrown while transmitting the message" }
};
await args.Request.SendResponseAsync(Value);
}
finally
{
Deferral.Complete();
}
}
private void CommunicationService_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string cmd = message["Command"] as string;
try
{
// Return the data to the caller.
if (cmd == "Log")
{
string level = message["Level"] as string;
string msg = message["Message"] as string;
switch (level)
{
case "Comment":
Log.Comment("[Host] {0}", msg);
break;
case "Warning":
Log.Warning("[Host] {0}", msg);
break;
case "Error":
Log.Error("[Host] {0}", msg);
break;
}
}
}
catch (Exception e)
{
Log.Error("Exception receiving message: {0}", e.Message);
}
finally
{
// Complete the deferral so that the platform knows that we're done responding to the app service call.
// Note: for error handling: this must be called even if SendResponseAsync() throws an exception.
messageDeferral.Complete();
}
}
private async void Initialize()
{
try
{
// this is the unique package family name of the Console Ouput app
const string consoleOutputPackageFamilyName = "49752MichaelS.Scherotter.ConsoleOutput_9eg5g21zq32qm";
var options = new LauncherOptions
{
PreferredApplicationDisplayName = "Console Output",
PreferredApplicationPackageFamilyName = consoleOutputPackageFamilyName,
TargetApplicationPackageFamilyName = consoleOutputPackageFamilyName,
};
// launch the ConsoleOutput app
var uri = new Uri(string.Format("consoleoutput:?Title={0}&input=true", Windows.ApplicationModel.Package.Current.DisplayName));
if (!await Launcher.LaunchUriAsync(uri, options))
{
return;
}
var appServiceConnection = new AppServiceConnection
{
AppServiceName = "consoleoutput",
PackageFamilyName = consoleOutputPackageFamilyName
};
var status = await appServiceConnection.OpenAsync();
if (status == AppServiceConnectionStatus.Success)
{
_appServiceConnection = appServiceConnection;
// because we want to get messages back from the console, we
// launched the app with the input=true parameter
_appServiceConnection.RequestReceived += OnRequestReceived;
}
}
catch (Exception ex)
{
Debug.WriteLine("Error initializing {0} -- {1}", nameof(UwpConsoleOutputProvider), ex);
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral deferral = args.GetDeferral();
ValueSet message = args.Request.Message;
switch (message["type"])
{
case "connect":
{
VoiceServerUpdate data = JsonConvert.DeserializeObject <VoiceServerUpdate>(message["config"] as string);
VoiceState state = JsonConvert.DeserializeObject <VoiceState>(message["state"] as string);
webrtcManager.SetRecordingDevice(message["inputId"] as string);
webrtcManager.SetPlaybackDevice(message["outputId"] as string);
ConnectToVoiceChannel(data, state);
}
break;
case "disconnect":
webrtcManager.Destroy();
voipCall?.NotifyCallEnded();
voipCall = null;
voiceConnection = null;
break;
case "voiceStateUpdate":
{
// Todo: handle here
VoiceState state = JsonConvert.DeserializeObject <VoiceState>(message["state"] as string);
}
break;
case "inputDevice":
webrtcManager.SetRecordingDevice(message["id"] as string);
break;
case "outputDevice":
webrtcManager.SetPlaybackDevice(message["id"] as string);
break;
}
deferral.Complete();
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string cmd = message["cmd"] as string;
string txt = message["txt"] as string;
switch (cmd)
{
case "Encode":
{
var messageDeferral = args.GetDeferral();
string result = Encode(txt);
var returnMessage = new ValueSet();
returnMessage.Add("result", result);
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
}
case "Decode":
{
var messageDeferral = args.GetDeferral();
string result = Decode(txt);
var returnMessage = new ValueSet();
returnMessage.Add("result", result);
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
}
case "Quit":
{
serviceDeferral.Complete();
break;
}
}
}
/// <summary>
/// Creates the app service connection
/// </summary>
static void ThreadProc()
{
connection = new AppServiceConnection();
connection.AppServiceName = "CommunicationService";
connection.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
connection.RequestReceived += Connection_RequestReceived;
var ax = connection.OpenAsync();
ax.Completed = (info, asyncStatus) =>
{
AppServiceConnectionStatus status = info.GetResults();
switch (status)
{
case AppServiceConnectionStatus.Success:
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Connection established - waiting for requests");
Console.WriteLine();
break;
case AppServiceConnectionStatus.AppNotInstalled:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The app AppServicesProvider is not installed.");
return;
case AppServiceConnectionStatus.AppUnavailable:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The app AppServicesProvider is not available.");
return;
case AppServiceConnectionStatus.AppServiceUnavailable:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The app AppServicesProvider is installed but it does not provide the app service {0}.", connection.AppServiceName);
return;
case AppServiceConnectionStatus.Unknown:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Format("An unkown error occurred while we were trying to open an AppServiceConnection."));
return;
}
};
}
private async void FileReceiver_FileTransferProgress(FileTransfer.FileTransferProgressEventArgs e)
{
ShowFileTransferProgressToast(e);
await notificationSemaphoreSlim.WaitAsync();
waitingNumSemaphore++;
#if NOTIFICATIONHANDLER_DEBUGINFO
System.Diagnostics.Debug.WriteLine("Progress " + e.CurrentPart + "/" + e.Total + " : " + e.State);
#endif
if (!await ConnectToNotificationService())
{
waitingNumSemaphore--;
notificationSemaphoreSlim.Release();
return;
}
try
{
// Call the service.
var message = new ValueSet();
message.Add("Type", "FileTransferProgress");
message.Add("Data", JsonConvert.SerializeObject(e));
AppServiceResponse response = await this.notificationService.SendMessageAsync(message);
if (response.Status != AppServiceResponseStatus.Success)
{
Debug.WriteLine("Failed to send message to notification service: " + response.Status);
notificationService = null;
}
}
catch (Exception ex)
{
Debug.WriteLine("Failed to send message to notification service (an exception was thrown): " + ex.ToString());
notificationService = null;
}
waitingNumSemaphore--;
notificationSemaphoreSlim.Release();
}
private async Task SendMessageToRemoteAppServiceAsync(AppServiceConnection connection)
{
// Send message if connection to the remote app service is open.
if (connection != null)
{
//Set up the inputs and send a message to the service.
ValueSet inputs = new ValueSet();
inputs.Add("minvalue", m_minimumValue);
inputs.Add("maxvalue", m_maximumValue);
UpdateStatus("Sent message to remote app service. Waiting for a response...", NotifyType.StatusMessage);
AppServiceResponse response = await connection.SendMessageAsync(inputs);
if (response.Status == AppServiceResponseStatus.Success)
{
if (response.Message.ContainsKey("result"))
{
string resultText = response.Message["result"].ToString();
if (string.IsNullOrEmpty(resultText))
{
UpdateStatus("Remote app service did not respond with a result.", NotifyType.ErrorMessage);
}
else
{
UpdateStatus("Result = " + resultText, NotifyType.StatusMessage);
}
}
else
{
UpdateStatus("Response from remote app service does not contain a result.", NotifyType.ErrorMessage);
}
}
else
{
UpdateStatus("Sending message to remote app service failed with error - " + response.Status.ToString(), NotifyType.ErrorMessage);
}
}
else
{
UpdateStatus("Not connected to any app service. Select a device to open a connection.", NotifyType.ErrorMessage);
}
}
private void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// win32 component finished
if (taskCompletionSource == null)
{
return;
}
object result;
args.Request.Message.TryGetValue("RESULT", out result);
if ((string)result == "SUCCESS")
{
taskCompletionSource.TrySetResult(true);
}
else
{
LogService.Log.Error($"FullTrustProcess returned an error. ({ApplicationData.Current.LocalSettings.Values["fullTrustProcessError"]})");
taskCompletionSource.TrySetResult(false);
}
}
private void Close()
{
var taskDeferral = Interlocked.Exchange(ref this.taskDeferral, null);
if (taskDeferral is null)
{
return;
}
AppServiceHandler.RemoveUnused(this.appServiceConnection);
this.appServiceConnection.RequestReceived -= OnAppServiceRequestReceived;
this.appServiceConnection.ServiceClosed -= OnServiceClosed;
this.appServiceConnection.Dispose();
this.appServiceConnection = null;
this.taskInstance.Canceled -= OnBackgroundTaskCanceled;
this.taskInstance = null;
taskDeferral.Complete();
}
/// <summary>
/// Receives message from UWP app and sends a response back
/// </summary>
private static void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var input = args.Request.Message;
if (input["Request"].ToString() == "Conversion")
{
ValueSet returnData = new ValueSet();
double amount = Convert.ToInt32(input["Amount"] as string);
int period = Convert.ToInt32(input["Period"] as string);
double rate = Convert.ToDouble(input["Rate"] as string);
ValueSet valueSet = new ValueSet();
valueSet.Add("Response", GEtEMI(amount, period, rate).ToString());
args.Request.SendResponseAsync(valueSet).Completed += delegate { };
}
else if (input["Request"].ToString() == "ColorChange")
{
mainWindowCallback.OnBackgroundColorChange(input["ColorCode"].ToString());
}
}
private async Task <bool> ConnectAsync()
{
if (_appServiceConnection != null)
{
return(true);
}
var appServiceConnection = new AppServiceConnection();
appServiceConnection.AppServiceName = "InProcessAppService";
appServiceConnection.PackageFamilyName = Package.Current.Id.FamilyName;
appServiceConnection.RequestReceived += AppServiceConnection_RequestReceived;
var r = await appServiceConnection.OpenAsync() == AppServiceConnectionStatus.Success;
if (r)
{
_appServiceConnection = appServiceConnection;
}
return(r);
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var op = args.Request.Message["Op"] as string;
var res = new ValueSet();
if (op == "Clipboard")
{
res.Add("Res", await RunAsync(GetClipboard));
}
else
{
res.Add("Res", string.Empty);
}
Debug.WriteLine($"Clipboard: {res["Res"].ToString()}");
var status = await args.Request.SendResponseAsync(res);
deferral.Complete();
Debug.WriteLine($"SendStatus: {status.ToString()}");
}
public static async void CreateAppService(RemoteSystem remoteSystem)
{
AppServiceConnection connection = new AppServiceConnection();
connection.AppServiceName = "com.microsoft.test.cdppingpongservice";
connection.PackageFamilyName = Package.Current.Id.FamilyName;
RemoteSystemConnectionRequest connectionRequest = new RemoteSystemConnectionRequest(remoteSystem);
var status = await connection.OpenRemoteAsync(connectionRequest);
if (SuccessfulAppServiceClientConnectionStatus(status, connection, remoteSystem) == true)
{
connection.RequestReceived += PingPongConnection.OnRequestReceived;
NotifyAppServiceConnected(connection);
}
else
{
DebugWrite($"Failed to create app service connection to ({remoteSystem.DisplayName}, {remoteSystem.Id})");
}
}
/// <summary>
/// Handles AppServiceConnection opening.
/// </summary>
/// <param name="args">Background Activation details.</param>
protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
base.OnBackgroundActivated(args);
IBackgroundTaskInstance taskInstance = args.TaskInstance;
if (taskInstance.Task.Name == "SuspendBackgroundTask")
{
_suspendDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += SuspendTask_OnCanceled;
}
else
{
AppServiceTriggerDetails appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
_appServiceDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += TaskInstance_OnCanceled;
_appServiceConnection = appService.AppServiceConnection;
_appServiceConnection.RequestReceived += HandleServiceRequest;
ConnectedToAppService?.Invoke(null, null);
}
}
private async Task <string> ResubmitRequestAppServiceAsync(HwandazaCommand command)
{
//re-establish appservice connection
await AppServiceInstance.SetAppServiceConnection();
_appServiceConnection = AppServiceInstance.Instance.GetAppServiceConnection();
var responseContent = "{}";
var appServiceResponse = RequestAppServiceAsync(command).Result;
if (appServiceResponse != null)
{
if (appServiceResponse.Status == AppServiceResponseStatus.Success)
{
responseContent = appServiceResponse.Message["Response"] as string;
}
}
return(responseContent);
}
