/// <summary>
/// Receives message from Extension (via Edge)
/// </summary>
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
if (this.centennialAppLaunched)
{
this.currentConnectionIndex = Int32.Parse(sender.AppServiceName);
this.centennialConnection = centennialConnections[this.currentConnectionIndex];
// Send message to the Centennial component and wait for response
AppServiceResponse centennialResponse = await this.centennialConnection.SendMessageAsync(args.Request.Message);
await args.Request.SendResponseAsync(centennialResponse.Message);
}
else
{
throw new Exception("Failed to launch Centennial App!");
}
}
finally
{
messageDeferral.Complete();
}
}
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();
}
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
Dictionary <string, object> Request = new Dictionary <string, object>();
Dictionary <string, object> Response = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> keyValuePair in args.Request.Message)
{
Request.Add(keyValuePair.Key, keyValuePair.Value);
}
AppPwdService.Consume(Request, out Response);
foreach (KeyValuePair <string, object> keyValuePair in Response)
{
ValueSet message = new ValueSet
{
{ keyValuePair.Key, keyValuePair.Value }
};
await args.Request.SendResponseAsync(message);
}
}
finally
{
messageDeferral.Complete();
}
}
public ASRequest(AppServiceRequest internalRequest, AppServiceDeferral internalRequestDeferral,
ASConnection connection)
{
_connection = connection;
_internalRequest = internalRequest;
_internalRequestDeferral = internalRequestDeferral;
Message = _connection._serializer.DeserializeFromValueSet(internalRequest.Message);
}
public async Task HandleDeferral(AppServiceDeferral deferral, AppServiceRequest request)
{
StartupTask.WriteTelemetryEvent("Action_AppService");
ValueSet returnMessage = new ValueSet();
await request.SendResponseAsync(returnMessage);
deferral.Complete();
}
protected override async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// Echo service. Send back what we received.
AppServiceDeferral defferal = args.GetDeferral();
await SendResponseMessageAsync(args.Request, args.Request.Message);
defferal.Complete();
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
var message = await ConnectedService.Instance.HandleMessageReceivedAsync(args.Request.Message, null, _appServiceconnection);
await args.Request.SendResponseAsync(message);
messageDeferral.Complete();
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
var result = new ValueSet();
GazeSettings.ValueSetFromLocalSettings(result);
await args.Request.SendResponseAsync(result);
messageDeferral.Complete();
}
/// <summary>
/// Receives message from UWP app and sends a response back
/// </summary>
private static async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
var value = args.Request.Message.First().Value.ToString();
var jsonSerializer = new JavaScriptSerializer();
var response = new ValueSet();
try
{
var valueList = (IDictionary <string, object>)jsonSerializer.DeserializeObject(value);
string messageType = valueList["action"].ToString();
switch (messageType)
{
case "search_tsvn":
var tsvnPath = SearchTsvn();
if (tsvnPath != "")
{
response.Add("message", jsonSerializer.Serialize(new { result = true, data = tsvnPath }));
}
else
{
response.Add("message", jsonSerializer.Serialize(new { result = true, data = false }));
}
break;
case "tsvn":
var path = valueList["path"].ToString();
var tsvn_args = ((object[])valueList["args"]).Select(o => (string)o).ToArray();
var ret = RunTsvn(path, tsvn_args);
response.Add("message", jsonSerializer.Serialize(new { result = ret }));
break;
default:
response.Add("message", jsonSerializer.Serialize(new { result = false, error = "Unknown action" }));
break;
}
}
catch (System.Exception e)
{
response = new ValueSet();
response.Add("message", jsonSerializer.Serialize(new { result = false, error = e.ToString() }));
}
await args.Request.SendResponseAsync(response);
}
finally
{
messageDeferral.Complete();
Application.Exit();
}
}
private void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral deferral = args.GetDeferral();
if (args.Request.Message.ContainsKey("refresh"))
{
App_Refresh();
}
if (args.Request.Message.ContainsKey("redraw"))
{
DWM.Draw();
}
if (args.Request.Message.ContainsKey("padding_read"))
{
App_SendPadding();
}
if (args.Request.Message.ContainsKey("padding_set"))
{
args.Request.Message.TryGetValue("padding_set", out object message);
int newPadding = int.Parse(message.ToString());
DWM.Padding = newPadding;
Properties.Settings.Default.Padding = newPadding;
Properties.Settings.Default.Save();
}
if (args.Request.Message.ContainsKey("filters_set"))
{
args.Request.Message.TryGetValue("filters_set", out object message);
List <List <string> > receivedFilters = JsonConvert.DeserializeObject <List <List <string> > >(message.ToString());
List <Pair <string, string> > parsedFilters = new List <Pair <string, string> >();
foreach (List <string> f in receivedFilters)
{
parsedFilters.Add(new Pair <string, string>(
f[0],
f[1]
));
}
DWM.ConfigurableFilters = parsedFilters;
Properties.Settings.Default.Filters = JsonConvert.SerializeObject(parsedFilters);
Properties.Settings.Default.Save();
DWM.ClearWindows();
DWM.GetWindows();
DWM.Draw();
}
deferral.Complete();
}
/// <summary>
/// Receives message from Extension (via Edge)
/// </summary>
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string value = args.Request.Message.First().Value.ToString();
ValueSet returnMessage = new ValueSet();
returnMessage.Add("message", "type and value:" + value);
await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
}
/// <summary>
/// Receives message from desktopBridge App
/// </summary>
private async void OndesktopBridgeAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
await connections[Int32.Parse(sender.AppServiceName)].SendMessageAsync(args.Request.Message);
}
finally
{
messageDeferral.Complete();
}
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
if (message.ContainsKey("LIDAR"))
{
await args.Request.SendResponseAsync(_lidar.ReturnData());
messageDeferral.Complete();
return;
}
Device receivedFromAddress = (Device)message["ADDRESS"];
switch (receivedFromAddress)
{
case Device.Wheel:
_wheel.ExecuteWheelCommand(message);
break;
case Device.Ultrasonic:
if (message.ContainsKey("REQUEST"))
{
await args.Request.SendResponseAsync(_ultrasound.ReturnData());
}
break;
case Device.EncoderLeft:
if (message.ContainsKey("REQUEST"))
{
await args.Request.SendResponseAsync(_encoderLeft.ReturnData());
}
break;
case Device.EncoderRight:
if (message.ContainsKey("REQUEST"))
{
await args.Request.SendResponseAsync(_encoderRight.ReturnData());
}
break;
case Device.GyroAccelerometer:
break;
default:
throw new ArgumentOutOfRangeException($"Received request from invalid device address {receivedFromAddress}");
}
messageDeferral.Complete();
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string text = message["item"] as string;
if (text == "cheeseburger")
{
ValueSet returnMessage = new ValueSet();
returnMessage.Add("price", "3.99");
await args.Request.SendResponseAsync(returnMessage);
}
messageDeferral.Complete();
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string text = message["Request"] as string;
if ("Value" == text)
{
ValueSet returnMessage = new ValueSet();
returnMessage.Add("Response", "True");
await args.Request.SendResponseAsync(returnMessage);
}
messageDeferral.Complete();
}
private async void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral Deferral = args.GetDeferral();
try
{
AppServiceConnection ServerConnection = null;
if (SpinWait.SpinUntil(() => PairedConnections.ContainsKey(sender), 5000))
{
ServerConnection = PairedConnections[sender];
}
if (ServerConnection != null)
{
AppServiceResponse ServerRespose = await ServerConnection.SendMessageAsync(args.Request.Message);
if (ServerRespose.Status == AppServiceResponseStatus.Success)
{
await args.Request.SendResponseAsync(ServerRespose.Message);
}
else
{
await args.Request.SendResponseAsync(new ValueSet { { "Error", "Can't not send message to server" } });
}
}
else
{
ValueSet Value = new ValueSet
{
{ "Error", "Failed to wait a server connection within the specified time" }
};
await args.Request.SendResponseAsync(Value);
}
}
catch
{
ValueSet Value = new ValueSet
{
{ "Error", "Some exceptions were threw while transmitting the message" }
};
await args.Request.SendResponseAsync(Value);
}
finally
{
Deferral.Complete();
}
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string text = message["input"] as string;
OnDataReceived(text);
ValueSet returnMessage = new ValueSet();
returnMessage.Add("ack", "OK");
await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
string request = message["Request"] as string;
string val = message["Value"] as string;
if ("CAPITALIZE" == request)
{
ValueSet returnMessage = new ValueSet();
returnMessage.Add("Response", val.ToUpper());
await args.Request.SendResponseAsync(returnMessage);
}
messageDeferral.Complete();
}
/// <summary>
/// Receives message from Centennial App
/// </summary>
private async void OnCentennialAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
this.currentConnectionIndex = Int32.Parse(sender.AppServiceName);
this.connection = connections[this.currentConnectionIndex];
await this.connection.SendMessageAsync(args.Request.Message);
}
finally
{
messageDeferral.Complete();
}
}
public static async Task <ASConnection> AcceptConnectionAsync(AppServiceTriggerDetails e,
BackgroundTaskDeferral connectionDeferral, IObjectSerializer serializer)
{
// Receive connection request, send connection response
AppServiceRequest request = null;
AppServiceDeferral deferral = null;
var gotRequest = new SemaphoreSlim(0);
e.AppServiceConnection.RequestReceived += OnRequestReceived;
await gotRequest.WaitAsync();
e.AppServiceConnection.RequestReceived -= OnRequestReceived;
var message = serializer.DeserializeFromValueSet(request.Message);
if (message is ConnectionRequestMessage connectionRequest)
{
// Accept connection request
var connectionId = "AS_" + Guid.NewGuid();
var connectionResponse = new ConnectionResponseMessage(connectionId);
await request.SendResponseAsync(serializer.SerializeToValueSet(connectionResponse));
deferral.Complete();
return(new ASConnection(
connectionId, e.AppServiceConnection, connectionDeferral,
e.IsRemoteSystemConnection, serializer));
}
else
{
// Wrong message received => reject connection
var connectionResponse = new ConnectionResponseMessage(null);
await request.SendResponseAsync(serializer.SerializeToValueSet(connectionResponse));
deferral.Complete();
connectionDeferral.Complete();
e.AppServiceConnection.Dispose();
return(null);
}
void OnRequestReceived(AppServiceConnection _, AppServiceRequestReceivedEventArgs r)
{
request = r.Request;
deferral = r.GetDeferral();
gotRequest.Release();
}
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral msgDeferral = args.GetDeferral();
ValueSet msg = args.Request.Message;
try
{
string request = msg["request"] as string;
ValueSet response = new();
bool validRequest = true;
switch (request)
{
case "is_running":
response.Add("response", isRunning && UiUtils.IsWindowActivated ? "true" : "false");
break;
case "is_connected":
string bareJid = msg["bare_jid"] as string;
Client client = ConnectionHandler.INSTANCE.GetClient(bareJid)?.client;
bool connected = client is not null && client.xmppClient.isConnected();
response.Add("response", connected ? "true" : "false");
break;
case "init_push":
PushManager.INSTANCE.Init();
response.Add("response", "true");
break;
default:
Logger.Warn($"Unknown app service request '{request}' received!");
validRequest = false;
break;
}
if (validRequest)
{
_ = await args.Request.SendResponseAsync(response);
}
}
catch (Exception e)
{
Logger.Error("Processing the app service request failed.", e);
}
msgDeferral.Complete();
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
int id = (int)args.Request.Message["id"];
switch (id)
{
case 1001:
case 1002: //center active window position
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
//paw.CenterActiveWindowPosition(); // using default parameter settings when none provided
});
break;
case 1003:
case 1004: //swap mouse buttons
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
//var currentSetting = smb.GetMouseButtonsSetting();
//if (currentSetting == MouseButtonsSetting.RightHanded) smb.SetMouseButtonsSetting(MouseButtonsSetting.LeftHanded);
//else /* (currentSetting == MouseButtonSettings.LeftHanded) */ smb.SetMouseButtonsSetting(MouseButtonsSetting.RightHanded);
});
break;
//case 1005:
//case 1006://lock and engage modern standby vs legacy [s3] suspend
// await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
// {
// // TODO: implement lock and engage modern standby vs legacy [s3] suspend
// });
// break;
default:
break;
}
await args.Request.SendResponseAsync(new ValueSet());
messageDeferral.Complete();
// we no longer need the connection
App.AppServiceDeferral.Complete();
App.Connection = null;
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
var controller = App.Services.GetService <AppServiceController>();
if (controller is not null)
{
await controller.ProcessRequest(args.Request);
}
else
{
var message = new ValueSet();
message.Add("result", "Fail. Launch Ambie in the foreground to use its app services.");
await args.Request.SendResponseAsync(message);
}
messageDeferral.Complete();
}
/// <summary>
/// Receives message from Extension (via Edge)
/// </summary>
private async Task OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args, int index)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
TaskCompletionSource <bool> tcs = null;
ConnectionDeferral cd = null;
lock (thisLock)
{
if (desktopConnectionMap.ContainsKey(index))
{
cd = desktopConnectionMap[index];
}
else
{
tcs = new TaskCompletionSource <bool>();
taskCompletionSourceMap.Add(index, tcs);
}
}
if (tcs != null)
{
await tcs.Task;
lock (thisLock)
{
if (!desktopConnectionMap.ContainsKey(index))
{
return;
}
cd = desktopConnectionMap[index];
}
}
var desktopConnection = cd.connection;
// Send message to the desktopBridge component and wait for response
AppServiceResponse desktopResponse = await desktopConnection.SendMessageAsync(args.Request.Message);
await args.Request.SendResponseAsync(desktopResponse.Message);
}
finally
{
messageDeferral.Complete();
}
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// Get a deferral because we use an awaitable API below (SendResponseAsync()) to respond to the message
// and we don't want this call to get cancelled while we are waiting.
AppServiceDeferral messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
ValueSet returnMessage = new ValueSet();
string data = message["data"] as string;
if (data != null)
{
returnMessage.Add("Result", new string(data.ToCharArray().Reverse().ToArray()));
}
await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
}
private async void OnAppServiceRequestReceived(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 == "Start")
{
var pageName = message["Page"] as string;
Log.Comment("Received request for Page: {0}", pageName);
ValueSet returnMessage = new ValueSet();
// We await the OpenPage method to ensure the navigation has finished.
if (await WeakReferenceMessenger.Default.Send(new RequestPageMessage(pageName)))
{
returnMessage.Add("Status", "OK");
}
else
{
returnMessage.Add("Status", "BAD");
}
await args.Request.SendResponseAsync(returnMessage);
}
}
catch (Exception e)
{
// Your exception handling code here.
Log.Error("Exception processing request: {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 AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
bool isLock = (bool)args.Request.Message["Lock"];
switch (isLock)
{
case true: //stingray
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
MessageDialog dlg = new MessageDialog("The Screen Locked");
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
await dlg.ShowAsync();
});
});
break;
case false: //octopus
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
MessageDialog dlg = new MessageDialog("The Screen UnLocked");
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
await dlg.ShowAsync();
});
});
break;
default:
break;
}
await args.Request.SendResponseAsync(new ValueSet());
messageDeferral.Complete();
// we no longer need the connection
App.AppServiceDeferral.Complete();
App.Connection = null;
}
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 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();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
if (!(taskInstance.TriggerDetails is AppServiceTriggerDetails appServiceTriggerDetails))
{
return;
}
AppServiceConnection appServiceConnection = appServiceTriggerDetails.AppServiceConnection;
appServiceConnection.RequestReceived += async(sender, args) =>
{
AppServiceDeferral appServiceDeferral = args.GetDeferral();
AppServiceRequest appServiceRequest = args.Request;
ValueSet request = appServiceRequest.Message;
await appServiceRequest.SendResponseAsync(new ValueSet { { "count", request.Count } });
appServiceDeferral.Complete();
};
}
private async void OnNotificationAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
ValueSet message = args.Request.Message;
if (message["Type"].ToString() == "FileTransferProgress")
{
await DispatcherEx.RunOnCoreDispatcherIfPossible(async() =>
{
await NotificationHandler.HandleAsync(JsonConvert.DeserializeObject <FileTransfer2ProgressEventArgs>(message["Data"] as string));
});
}
else if (message["Type"].ToString() == "TextReceive")
{
await DispatcherEx.RunOnCoreDispatcherIfPossible(async() =>
{
await NotificationHandler.HandleAsync(JsonConvert.DeserializeObject <TextReceiveEventArgs>(message["Data"] as string));
});
}
ValueSet returnMessage = new ValueSet();
returnMessage.Add("Status", "OK");
await args.Request.SendResponseAsync(returnMessage);
}
catch (Exception ex)
{
Debug.WriteLine("Unhandled exception in OnAppServiceRequestReceived():");
Debug.WriteLine(ex.ToString());
await(new MessageDialog(ex.ToString(), "Unhandled exception in OnAppServiceRequestReceived()")).ShowAsync();
}
finally
{
messageDeferral.Complete();
}
}
public void Dispose()
{
_deferral.Complete();
_deferral = null;
}
public AppServiceDeferralWrapper(AppServiceDeferral deferral)
{
_deferral = deferral;
}
