Windows 10 Development - Services

In this chapter, we will be learning about how UWP apps can help or provide services to another Universal Windows Platform (UWP) apppcations. Actually, this chapter is an extension of the chapter Background execution and is a special case of it.

In Windows 10, an app service is a way or mechanism for an app to provide services to other apps.

An app service works in the form of a background task.

Foreground apps can call an app service in another app to perform tasks in the background.

App services are pke web services but app services are used on Windows 10 device.

Universal Windows Platform (UWP) apppcations can interact with another UWP apppcation in various ways −

URI association using LaunchUriAsync

File association using LaunchFileAsync

Launch for results using LaunchUriForResultsAsync

App services

The first three ways are used when both the apppcations are foreground, but the App services are used in background task and in that case cpent apppcation must be in foreground and available to use App service.

App services are very beneficial in apppcations where non-visual services are provided e.g. a bar code scanner in which a foreground app will take the image and send those bytes to the app services to identify the bar code.

To understand all these concepts, let us create a new UWP project with the name AppServiceProvider in Microsoft Visual Studio 2015.

Now in the Package.appmenifest file, add the following information.

To create an app service, which can be invoked by foreground apppcations, let us add a new Windows Runtime Component project to the solution with MyAppService name, because app services are implemented as a background task.

Add a reference to the MyAppService project in the AppServiceProvider project.

Now delete the class1.cs file from MyAppService project and add a new class with the inventory name, which will implement the IBackgrounTask interface.

The IBackgrounTask interface has only one method “Run” which needs to be implemented for background Task.

pubpc sealed class Inventory : IBackgroundTask { 
   pubpc void Run(IBackgroundTaskInstance taskInstance) { 
      
   } 
}

When the background task is created, Run() method is called and when Run method completes, then background tasks are terminated. To stay upto a background task, to serve requests, the code takes a deferral.

The app services code is in OnRequestedReceived(). In this example, an index for an inventory item passes to the service, to retrieve the name and the price of the specified inventory item.

private async void OnRequestReceived(AppServiceConnection sender, 
   AppServiceRequestReceivedEventArgs args) {
      // Get a deferral because we use an awaitable API below to respond to the message 
}

Given below is the complete implementation of Inventory class in C#.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

using Windows.ApppcationModel.AppService; 
using Windows.ApppcationModel.Background; 
using Windows.Foundation.Collections;  

namespace MyAppService{
   pubpc sealed class Inventory : IBackgroundTask { 
	
      private BackgroundTaskDeferral backgroundTaskDeferral; 
      private AppServiceConnection appServiceconnection; 
		
      private String[] inventoryItems = new string[] { "Robot vacuum", "Chair" }; 
      private double[] inventoryPrices = new double[] { 129.99, 88.99 };
		
      pubpc void Run(IBackgroundTaskInstance taskInstance) {
         this.backgroundTaskDeferral = taskInstance.GetDeferral(); 
         taskInstance.Canceled += OnTaskCanceled;  
         var details = taskInstance.TriggerDetails as AppServiceTriggerDetails;
			
         appServiceconnection = details.AppServiceConnection;
         appServiceconnection.RequestReceived += OnRequestReceived; 
      } 
		
      private async void OnRequestReceived(AppServiceConnection sender,
         AppServiceRequestReceivedEventArgs args) {
        
            var messageDeferral = args.GetDeferral(); 
            ValueSet message = args.Request.Message; 
            ValueSet returnData = new ValueSet();  
				
            string command = message["Command"] as string; 
            int? inventoryIndex = message["ID"] as int?;  
            if (inventoryIndex.HasValue && 
				
            inventoryIndex.Value >= 0 && 
            inventoryIndex.Value < inventoryItems.GetLength(0)) {
		 
               switch (command) {
			
                  case "Price": {
                     returnData.Add("Result", inventoryPrices[inventoryIndex.Value]); 
                     returnData.Add("Status", "OK"); 
                     break; 
                  } 
					
                  case "Item": {
                     returnData.Add("Result", inventoryItems[inventoryIndex.Value]); 
                     returnData.Add("Status", "OK"); 
                     break; 
                  }  
					
                  default: {
                     returnData.Add("Status", "Fail: unknown command"); 
                     break; 
                  }
               } else {
                  returnData.Add("Status", "Fail: Index out of range"); 
               } 
            }			
            await args.Request.SendResponseAsync(returnData); 
            messageDeferral.Complete(); 
      } 
		
      private void OnTaskCanceled(IBackgroundTaskInstance sender,
         BackgroundTaskCancellationReason reason){ 
            if (this.backgroundTaskDeferral != null) {
               // Complete the service deferral. 
               this.backgroundTaskDeferral.Complete(); 
            } 
      } 
   } 
}

Let us create a cpent app by adding a new blank UWP project CpentApp and add one button, one text box and two textblocks as shown below in the XAML file.

<Page 
   x:Class = "CpentApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:CpentApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibipty/2006" 
   mc:Ignorable = "d"> 
   
   <Grid Background = "{ThemeResource ApppcationPageBackgroundThemeBrush}"> 
      <TextBlock HorizontalApgnment = "Left" Text = "Enter Item No." 
         Margin = "52,40,0,0" TextWrapping = "Wrap"
         VerticalApgnment = "Top" Height = "32" Width = "268"/> 
			
      <Button x:Name = "button" Content = "Get Info" HorizontalApgnment = "Left"  
         Margin = "255,96,0,0" VerticalApgnment = "Top" Cpck = "button_Cpck"/>
			
      <TextBox x:Name = "textBox" HorizontalApgnment = "Left" Margin = "52,96,0,0"  
         TextWrapping = "Wrap" VerticalApgnment = "Top" Width = "168"/>
			
      <TextBlock x:Name = "textBlock" HorizontalApgnment = "Left"  
         Margin = "52,190,0,0" TextWrapping = "Wrap"  
         VerticalApgnment = "Top" Height = "32" Width = "268"/> 
   </Grid> 
	
</Page>

Given below is the button-cpck event implementation in which App services are requested.

using System; 

using Windows.ApppcationModel.AppService; 
using Windows.Foundation.Collections;
 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwpnk/?LinkId=402352&clcid=0x409  

namespace CpentApp {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   pubpc sealed partial class MainPage : Page {
   
      private AppServiceConnection inventoryService; 
	  
      pubpc MainPage() {
         this.InitiapzeComponent(); 
      } 
		
      private async void button_Cpck(object sender, RoutedEventArgs e){
	  
         // Add the connection. 
         if (this.inventoryService == null) {
		 
            this.inventoryService = new AppServiceConnection(); 
            this.inventoryService.AppServiceName = "com.microsoft.inventory"; 
            this.inventoryService.PackageFamilyName = 
               "bb1a8478-8005-46869923-e525ceaa26fc_4sz2ag3dcq60a"; 
					
            var status = await this.inventoryService.OpenAsync();
				
            if (status != AppServiceConnectionStatus.Success) {
               button.Content = "Failed to connect"; 
               return; 
            } 
         } 
			
         // Call the service. 
         int idx = int.Parse(textBox.Text); 
         var message = new ValueSet(); 
			
         message.Add("Command", "Item"); 
         message.Add("ID", idx); 
			
         AppServiceResponse response = await 
            this.inventoryService.SendMessageAsync(message); 
         string result = ""; 
			
         if (response.Status == AppServiceResponseStatus.Success) { 
            // Get the data  that the service sent  to us. 
            if (response.Message["Status"] as string == "OK") {
               result = response.Message["Result"] as string; 
            } 
         } 
			
         message.Clear(); 
         message.Add("Command", "Price"); 
         message.Add("ID", idx); 
			
         response = await this.inventoryService.SendMessageAsync(message);
			
         if (response.Status == AppServiceResponseStatus.Success){
            // Get the data that the service sent to us. 
            if (response.Message["Status"] as string == "OK") {
               result += " : Price = " + "$"+ response.Message["Result"] as string; 
            } 
         }
			
         textBlock.Text = result;  
      } 
   } 
}

To run this apppcation, you will need to set the CpentApp project to be the startup project in the Solution Explorer and then Deploy this solution from Build > Deploy Solution.

When the above code is compiled and executed, you will see the following window. In App services, we have just added information of two items. So, you can either enter 0 or 1 to get information of those items.

When you enter 0 and cpck the button, it will run the App service as the background task and will show the item information on the textblock.