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 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;
}
}
}
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 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 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 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();
}
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 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();
}
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 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 void OnCommandRecived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
if (command == "RegisterClient" || command == "Disc" || command == "ValueAck")
WriteToSerialPort(message["Value"] as string);
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var _requestDeferral = args.GetDeferral();
await StoreServicesFeedbackLauncher.GetDefault().LaunchAsync();
_requestDeferral.Complete();
}
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])
{
case BackgroundRequest.NewOutgoingCall:
Current.AppRequest = args.Request;
Current.Request = BackgroundRequest.NewOutgoingCall;
Current.AppRequestDeferal = deferral;
await Current.RequestNewCallAsync(message[NewCallArguments.ContactNumber.ToString()] as String,
message[NewCallArguments.ContactName.ToString()] as String,
message[NewCallArguments.ServiceName.ToString()] as String);
break;
case BackgroundRequest.NewIncomingCall:
Current.AppRequest = args.Request;
Current.Request = BackgroundRequest.NewIncomingCall;
Current.AppRequestDeferal = deferral;
await Current.RequestNewCallAsync(message[NewCallArguments.ContactNumber.ToString()] as String,
message[NewCallArguments.ContactName.ToString()] as String,
message[NewCallArguments.ServiceName.ToString()] as String);
break;
case BackgroundRequest.EndCall:
Current.AppRequest = args.Request;
Current.Request = BackgroundRequest.EndCall;
Current.AppRequestDeferal = deferral;
Current.EndCallAsync();
break;
case BackgroundRequest.GetCallDuration:
Current.AppRequest = args.Request;
Current.Request = BackgroundRequest.GetCallDuration;
Current.AppRequestDeferal = deferral;
await Current.GetCallDurationAsync();
break;
default:
stop = true;
break;
}
}
}
finally
{
if (stop)
{
_deferral.Complete();
}
}
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = (string)message["Command"];
switch (command)
{
case "GetSynonym":
{
var messageDeferral = args.GetDeferral();
string term = (string)message["Term"];
// Call the synonyms service
SynonymApi api = new SynonymApi(BING_KEY);
var returnMessage = new ValueSet();
try
{
var synonyms = await api.GetSynonymsAsync(term);
if ((synonyms != null) && (synonyms.Count() > 0))
{
//Set a result to return to the caller
//Serialize the IEnumerable<string> to Json so we can insert into ValueSet
returnMessage.Add("Result", JSONHelper.SerializeObject(synonyms));
}
else
{
// Report an error back to the caller
returnMessage.Add("Error", "No results found");
}
}
catch (Exception ex)
{
// Error accessing the service
// Report an error back to the caller
returnMessage.Add("Error", "Synonyms Service not available " + ex.Message + " term=" + term);
}
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 AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
if (null == StartupTask.s_radioManager)
{
StartupTask.WriteTelemetryEvent("AppServicesBackgroundTask_RadioNotRunning");
return;
}
await StartupTask.s_radioManager.GetAppServicesInterfaceManager().HandleDeferral(args.GetDeferral(), args.Request);
}
public void OnCommandRecived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
if (command.Equals("SerialBridge"))
{
var value = message["Value"] as string;
var device = message["Device"] as string;
WriteToSerialPort(value);
}
}
private void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
switch (command)
{
case "QUIT":
Close();
break;
}
}
private async void OnMessageReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string msgRequest = message["Request"] as string;
string msgResponse = message["Response"] as string;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
txtRequest.Text = msgRequest;
txtResponse.Text = msgResponse;
});
}
private void AppServiceConnection_RequestReceived(AppServiceConnection sender,
AppServiceRequestReceivedEventArgs args)
{
var request = args.Request;
_connection = sender;
var question = (string)request.Message["question"];
var response = new ValueSet();
response.Add("response", "You tell me!");
request.SendResponseAsync(response).AsTask();
var timer = new Timer(TimerCallBack, null, 10000, Timeout.Infinite);
}
private async void OnMessageReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string messageText = message["message"] as string;
string messageRepeat = message["repeat"] as string;
int repeat = 0;
if (messageRepeat != null)
{
repeat = Int32.Parse(messageRepeat);
}
// let's do this on a background thread
await System.Threading.Tasks.Task.Run(() => ScrollText(messageText, repeat));
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var appServiceDeferral = args.GetDeferral();
var message = args.Request.Message;
int num1 = (int)message["num1"];
int num2 = (int) message["num2"];
int sum = num1 + num2;
ValueSet result = new ValueSet();
result.Add("result", sum);
await args.Request.SendResponseAsync(result);
appServiceDeferral.Complete();
}
/// <summary>
/// Receives message from UWP app and sends a response back
/// </summary>
private static void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
string key = args.Request.Message.First().Key;
string value = args.Request.Message.First().Value.ToString();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(string.Format("Received message '{0}' with value '{1}'", key, value));
if (key == "request")
{
ValueSet valueSet = new ValueSet();
valueSet.Add("response", value.ToUpper());
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(string.Format("Sending response: '{0}'", value.ToUpper()));
Console.WriteLine();
args.Request.SendResponseAsync(valueSet).Completed += delegate { };
}
}
public async void OnCommandRecived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
if (command.Equals("BluetoothBridge"))
{
var value = message["Value"] as string;
var device = message["Device"] as string;
var writer = new DataWriter();
writer.WriteString(value);
await _writeCharacteristic.WriteValueAsync(writer.DetachBuffer());
}
}
/// <summary>
/// Called when we receive a request message on the com.microsoft.band.observer channel
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void OnRequestReceived(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();
ValueSet responseMessage = new ValueSet();
// Decode the received message and call the appropriate event handler
BackgroundTileEventHandler.Instance.HandleTileEvent(args.Request.Message);
// Send the response message
await args.Request.SendResponseAsync(responseMessage);
// Complete the deferral so that the platform knows that we're done responding
messageDeferral.Complete();
}
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 "XXXXXXX":
//Messenger.Default.Send(new LoadPhoto());
break;
}
await args.Request.SendResponseAsync(returnData);
msgDef.Complete();
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
string command = message["Command"] as string;
if (command.Equals("Bridge"))
{
_currentValue = message["SendToServer"] as string;
var messageDeferral = args.GetDeferral();
var returnMessage = new ValueSet();
returnMessage.Add("Status", "Success");
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
//await _webSockets.BroadcastMessage(command);
}
}
private async void requestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var lDeferral = args.GetDeferral();
try
{
var message = args.Request.Message;
var action = message["Action"] as String;
ValueSet response;
switch (action)
{
case "SetConfiguration":
Uri i;
if (!Uri.TryCreate(message["ServerUri"] as String, UriKind.Absolute, out i))
{
response = new ValueSet();
response["Status"] = false;
response["Message"] = "Invalid Server Uri";
await args.Request.SendResponseAsync(response);
}
else
{
var results = await controller.SetConfigurationAsync(i, message["Username"] as String, message["Password"] as String);
response = new ValueSet();
response["Status"] = results.Item1;
response["Message"] = results.Item2;
await args.Request.SendResponseAsync(response);
}
break;
case "GetConfiguration":
var result = await controller.GetConfigurationAsync();
response = new ValueSet();
response["Status"] = true;
response["ServerUri"] = result.Item1?.ToString();
response["Username"] = result.Item2;
await args.Request.SendResponseAsync(response);
break;
}
}
finally
{
lDeferral.Complete();
}
}
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.JsRTChakraCoreX.UI.Test");
returnData.Add("sketch-home", "X.Extension.ThirdParty.JsRTChakraCoreX.UI.Home");
break;
}
await args.Request.SendResponseAsync(returnData);
msgDef.Complete();
}
private async void AppServiceConnection_RequestReceived(
AppServiceConnection sender,
AppServiceRequestReceivedEventArgs args)
{
var appServiceDeferral = args.GetDeferral();
var msg = args.Request.Message;
var cmd = msg["cmd"] as string;
if (cmd == null) return;
if (cmd == "time")
{
var result = new ValueSet {{"time", DateTime.Now.ToString("T")}};
await args.Request.SendResponseAsync(result);
}
appServiceDeferral.Complete();
}
private async void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var requestMessage = args.Request.Message;
var responseMessage = new ValueSet();
foreach (var item in requestMessage)
{
if (groceries.ContainsKey(item.Value.ToString()))
{
responseMessage.Add(item.Value.ToString(), groceries[item.Value.ToString()]);
}
}
await args.Request.SendResponseAsync(responseMessage);
deferral.Complete();
}
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;
}
}
}
private async Task HandleSaveTextFileRequest(AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var messageContent = (string)args.Request.Message[MessageKeys.Content];
var request = JsonConvert.DeserializeObject <SaveTextFileRequest>(messageContent);
var response = new CommonResponse();
try
{
Utilities.SaveFile(request.Path, request.Content);
response.Success = true;
}
catch (Exception e)
{
response.Success = false;
response.Error = e.Message;
}
await args.Request.SendResponseAsync(CreateMessage(response));
deferral.Complete();
}
/// <summary>
/// Handles requests from the foreground by invoking the requested methods on a handler object
/// </summary>
private void HandleForegroundRequest(
AppServiceConnection sender,
AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
try
{
//Identiy the channel
var channel = args.Request.Message.Single().Key;
//Retrieve the message (format: <Method> <Argument - can be null and is serialized as JSON>)
var message = args.Request.Message.Single().Value.ToString();
//Invoke the requested method on the handler based on the channel type
if (channel == nameof(ISignalingSocketChannel))
{
AppServiceChannelHelper.HandleRequest(args.Request, SignalingSocketChannel, message);
}
if (channel == nameof(IClientChannel))
{
AppServiceChannelHelper.HandleRequest(args.Request, SignalingClient, message);
}
if (channel == nameof(ICallChannel))
{
AppServiceChannelHelper.HandleRequest(args.Request, CallChannel, message);
}
if (channel == nameof(IMediaSettingsChannel))
{
AppServiceChannelHelper.HandleRequest(args.Request, MediaSettingsChannel, message);
}
}
finally
{
deferral.Complete();
}
}
public override ValueSet OnRequest(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
string workDir = args.Request.Message["workDir"].ToString();
if (string.IsNullOrWhiteSpace(workDir))
{
return(null);
}
Logger.Info("Work dir is " + workDir);
Logger.Info("Creating KMCCC LauncherCore");
Program.Launcher = new OneMCL(workDir);
Assembly assembly = Assembly.GetExecutingAssembly();
AssemblyFileVersionAttribute ver = (AssemblyFileVersionAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyFileVersionAttribute));
Logger.Info("Version " + ver.Version);
ValueSet ret = new ValueSet();
ret["core-version"] = ver.Version;
return(ret);
}
private async void ConnectionRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// take out a deferral since we use await
var appServiceDeferral = args.GetDeferral();
try
{
await Debug("Request initiated by " + _thisConnectionGuid);
// .ToList() required since connections may get removed during SendMessage()
var otherConnections = Connections
.Where(i => i.Key != _thisConnectionGuid)
.ToList();
foreach (var connection in otherConnections)
{
await SendMessage(connection, args.Request.Message);
}
}
finally
{
appServiceDeferral.Complete();
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var messageDeferral = args.GetDeferral();
try
{
ValueSet returnData = new ValueSet();
var controller = GpioController.GetDefault();
using (var pin = controller.OpenPin(21))
{
pin.SetDriveMode(GpioPinDriveMode.Output);
pin.Write(GpioPinValue.High);
}
await args.Request.SendResponseAsync(returnData);
}
catch (Exception e) { /*ignore*/ }
finally
{
messageDeferral.Complete();
}
}
private async Task StartMessageAsync(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
Guid?id = null;
try
{
id = (Guid)args.Request.Message[ID_KEY];
if (this.idDirectory.ContainsKey(id.Value))
{
throw new Exceptions.PluginException("Start was already send.");
}
var cancellationTokenSource = new CancellationTokenSource();
this.idDirectory.Add(id.Value, cancellationTokenSource);
object output = await PerformStartAsync(sender, args, id, cancellationTokenSource);
var outputString = Helper.Serilize(output);
var valueSet = new Windows.Foundation.Collections.ValueSet();
valueSet.Add(ID_KEY, id.Value);
valueSet.Add(RESULT_KEY, outputString);
await args.Request.SendResponseAsync(valueSet);
}
catch (Exception e)
{
var valueSet = new ValueSet();
valueSet.Add(ERROR_KEY, e.Message);
valueSet.Add(ID_KEY, id.Value);
await args.Request.SendResponseAsync(valueSet);
}
finally
{
if (id.HasValue)
{
this.idDirectory.Remove(id.Value);
}
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var messageDeferral = args.GetDeferral();
ValueSet message = args.Request.Message;
ValueSet returnData = new ValueSet();
if (message.ContainsKey("Command"))
{
string command = message["Command"] as string;
// ... //
if (command == "CurrentWeather")
{
string resultJson = string.Empty;
var weatherData = await WeatherService.GetWeatherData();
var index = DateTime.Now.Hour / 6;
returnData.Add("Temperature", weatherData.Today[index].Temperature);
returnData.Add("State", weatherData.Today[index].Weather);
returnData.Add("Status", "OK");
}
else
{
returnData.Add("Status", "Fail: Unknown command");
}
}
else
{
returnData.Add("Status", "Fail: Missing command");
}
await args.Request.SendResponseAsync(returnData); // Return the data to the caller.
messageDeferral.Complete(); // Complete the deferral so that the platform knows that we're done responding to the app service call.
}
private async Task GetEffectAsync(AppServiceRequestReceivedEventArgs args)
{
var index = (int)args.Request.Message["Index"];
System.Diagnostics.Debug.Assert(index == 0);
var deferral = args.GetDeferral();
var uri = new Uri("ms-appx:///Public/ShadowEffect.xml");
var file = await StorageFile.GetFileFromApplicationUriAsync(uri);
var xml = await FileIO.ReadTextAsync(file);
var message = new ValueSet
{
["Name"] = "Shadow",
["Data"] = xml
};
await args.Request.SendResponseAsync(message);
deferral.Complete();
}
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
ValueSet message = args.Request.Message;
if (_wpfConnection == null)
{
if (message.TryGetValue("command", out object val) && val.ToString() == "StartEvents")
{
_wpfConnection = sender;
var response = new ValueSet
{
{ "result", "OK" }
};
await args.Request.SendResponseAsync(response);
}
// else nothing to do, WPF app not yet connected
}
else if (sender == _wpfConnection && message.TryGetValue("command", out object val) && val.ToString() == "StopEvents")
{
_wpfConnection.Dispose();
_wpfConnection = null;
}
else if (sender != _wpfConnection) // forward messages to WPF app
{
await _wpfConnection.SendMessageAsync(message);
var response = new ValueSet
{
{ "info", "forwarded message" }
};
await args.Request.SendResponseAsync(response);
}
deferral.Complete();
}
/// <summary>
/// Receives message from Extension (via Edge)
/// </summary>
private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral messageDeferral = args.GetDeferral();
try
{
if (desktopBridgeAppLaunched)
{
// Send message to the desktopBridge component and wait for response
AppServiceConnection desktopBridgeConnection = desktopBridgeConnections[Int32.Parse(sender.AppServiceName)];
AppServiceResponse desktopBridgeResponse = await desktopBridgeConnection.SendMessageAsync(args.Request.Message);
await args.Request.SendResponseAsync(desktopBridgeResponse.Message);
}
else
{
throw new Exception("Failed to launch desktopBridge App!");
}
}
finally
{
messageDeferral.Complete();
}
}
private async void _connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
try
{
if (args.Request.Message.TryGetValue("request", out var request) && request is string req)
{
switch (req)
{
case "connect":
await ConnectAsync(sender, args, deferral);
return;
default:
break;
}
}
}
catch { }
deferral.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();
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 static void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var request = (string)args.Request.Message["request"];
if (request == "Flash")
{
args.Request.SendResponseAsync(new ValueSet()).Completed += delegate { };
#if DEBUG
new Thread(new ThreadStart(() =>
{
var form = new Form();
form.Text = "Removing focus from App Window";
form.Shown += (s, e) => SetForegroundWindow(form.Handle);
form.ShowDialog();
})).Start();
#endif
var handle = new IntPtr((long)args.Request.Message["handle"]);
var parent = GetParent(handle);
var result = FlashWindow.Flash(parent);
//var handle = FindWindow("ApplicationFrameWindow", "TestFlash");
}
}
private void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var messageDefferal = args.GetDeferral();
var message = args.Request.Message;
string command = message["Command"] as string;
string value = message["Value"] as string;
messageDefferal.Complete();
switch (command)
{
case "SetMotorSpeed":
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
localSettings.Values["MotorSpeed"] = value;
Windows.Storage.ApplicationData.Current.SignalDataChanged();
break;
case "Quit":
//Service was asked to quit. Give us service deferral
//so platform can terminate the background task
serviceDeferral.Complete();
break;
}
}
public override ValueSet OnRequest(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
ValueSet valueSet = new ValueSet();
string versionId = args.Request.Message["version"].ToString();
if (string.IsNullOrEmpty(versionId))
{
return(null);
}
Logger.Info("Checking asset index for # " + versionId);
KMCCC.Launcher.Version ver = Program.Launcher.Core.GetVersion(versionId);
if (ver == null)
{
Logger.ErrorFormat("Version {0} dose not exist", versionId);
return(null);
}
Logger.Info("AssetIndex: " + ver.Assets);
var assetsResult = Program.Launcher.CheckAssets(ver);
if (!assetsResult.hasValidIndex)
{
Logger.Warn("Asset index dose not exist or invalid");
valueSet["index_url"] = ver.AssetsIndex.Url;
valueSet["index_path"] = string.Format(@"assets\indexes\{0}.json", ver.Assets);
return(valueSet);
}
Logger.Info(string.Format("Found {0} missing assets", assetsResult.missingAssets.Count));
string json = JsonConvert.SerializeObject(assetsResult.missingAssets);
valueSet["missing_assets"] = json;
return(valueSet);
}
private async Task HandleGetMoshSshExecutablePathRequest(AppServiceRequestReceivedEventArgs args)
{
var deferral = args.GetDeferral();
var messageContent = (string)args.Request.Message[MessageKeys.Content];
GetMoshSshExecutablePathRequest request = JsonConvert.DeserializeObject <GetMoshSshExecutablePathRequest>(messageContent);
GetMoshSshExecutablePathResponse response;
try
{
response = request.GetResponse();
}
catch (Exception e)
{
response = new GetMoshSshExecutablePathResponse {
Error = e.Message
};
}
await args.Request.SendResponseAsync(CreateMessage(response));
deferral.Complete();
}
private async static void Connection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
AppServiceDeferral Deferral = args.GetDeferral();
try
{
switch (args.Request.Message["ExecuteType"])
{
case "Execute_GetContextMenuItems":
{
IEnumerable <string> ExecutePath = JsonConvert.DeserializeObject <string[]>(Convert.ToString(args.Request.Message["ExecutePath"]));
bool IncludeExtensionItem = Convert.ToBoolean(args.Request.Message["IncludeExtensionItem"]);
List <(string, string, string)> ContextMenuItems = ContextMenu.FetchContextMenuItems(ExecutePath, IncludeExtensionItem);
ValueSet Value = new ValueSet
{
{ "Success", JsonConvert.SerializeObject(ContextMenuItems) }
};
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_InvokeContextMenuItem":
{
string Verb = Convert.ToString(args.Request.Message["InvokeVerb"]);
string[] Paths = JsonConvert.DeserializeObject <string[]>(Convert.ToString(args.Request.Message["ExecutePath"]));
ValueSet Value = new ValueSet();
if (!string.IsNullOrEmpty(Verb) && Paths.Length > 0)
{
if (ContextMenu.InvokeVerb(Paths, Verb))
{
Value.Add("Success", string.Empty);
}
else
{
Value.Add("Error", $"Execute Verb: {Verb} failed");
}
}
else
{
Value.Add("Error", "Verb is empty or Paths is empty");
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_ElevateAsAdmin":
{
Connection?.Dispose();
Connection = null;
using (Process AdminProcess = new Process())
{
AdminProcess.StartInfo.Verb = "runas";
AdminProcess.StartInfo.UseShellExecute = true;
AdminProcess.StartInfo.Arguments = $"Elevation_Restart {ExplorerProcess?.Id}";
AdminProcess.StartInfo.FileName = Process.GetCurrentProcess().MainModule.FileName;
AdminProcess.Start();
}
ExitLocker.Set();
break;
}
case "Execute_CreateLink":
{
string LinkPath = Convert.ToString(args.Request.Message["LinkPath"]);
string LinkTarget = Convert.ToString(args.Request.Message["LinkTarget"]);
string LinkDesc = Convert.ToString(args.Request.Message["LinkDesc"]);
string LinkArgument = Convert.ToString(args.Request.Message["LinkArgument"]);
ShellLink.Create(LinkPath, LinkTarget, description: LinkDesc, arguments: LinkArgument).Dispose();
ValueSet Value = new ValueSet
{
{ "Success", string.Empty }
};
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_GetVariable_Path":
{
ValueSet Value = new ValueSet();
string Variable = Convert.ToString(args.Request.Message["Variable"]);
string Env = Environment.GetEnvironmentVariable(Variable);
if (string.IsNullOrEmpty(Env))
{
Value.Add("Error", "Could not found EnvironmentVariable");
}
else
{
Value.Add("Success", Env);
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Rename":
{
string ExecutePath = Convert.ToString(args.Request.Message["ExecutePath"]);
string DesireName = Convert.ToString(args.Request.Message["DesireName"]);
ValueSet Value = new ValueSet();
if (File.Exists(ExecutePath) || Directory.Exists(ExecutePath))
{
if (StorageItemController.CheckOccupied(ExecutePath))
{
Value.Add("Error_Occupied", "FileLoadException");
}
else
{
if (StorageItemController.CheckPermission(FileSystemRights.Modify, Path.GetDirectoryName(ExecutePath)))
{
if (StorageItemController.Rename(ExecutePath, DesireName))
{
Value.Add("Success", string.Empty);
}
else
{
Value.Add("Error_Failure", "Error happened when rename");
}
}
else
{
Value.Add("Error_Failure", "No Modify Permission");
}
}
}
else
{
Value.Add("Error_NotFound", "FileNotFoundException");
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_GetHyperlinkInfo":
{
string ExecutePath = Convert.ToString(args.Request.Message["ExecutePath"]);
ValueSet Value = new ValueSet();
if (File.Exists(ExecutePath))
{
using (ShellLink Link = new ShellLink(ExecutePath))
{
Value.Add("Success", string.Empty);
Value.Add("TargetPath", Link.TargetPath);
Value.Add("Argument", Link.Arguments);
Value.Add("RunAs", Link.RunAsAdministrator);
Value.Add("IsFile", File.Exists(Link.TargetPath));
}
}
else
{
Value.Add("Error", "File is not exist");
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Intercept_Win_E":
{
ValueSet Value = new ValueSet();
string[] EnvironmentVariables = Environment.GetEnvironmentVariable("Path", EnvironmentVariableTarget.User).Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
if (EnvironmentVariables.Where((Var) => Var.Contains("WindowsApps")).Select((Var) => Path.Combine(Var, "RX-Explorer.exe")).FirstOrDefault((Path) => File.Exists(Path)) is string AliasLocation)
{
StorageFile InterceptFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Intercept_WIN_E.reg"));
StorageFile TempFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("Intercept_WIN_E_Temp.reg", CreationCollisionOption.ReplaceExisting);
using (Stream FileStream = await InterceptFile.OpenStreamForReadAsync().ConfigureAwait(true))
using (StreamReader Reader = new StreamReader(FileStream))
{
string Content = await Reader.ReadToEndAsync().ConfigureAwait(true);
using (Stream TempStream = await TempFile.OpenStreamForWriteAsync())
using (StreamWriter Writer = new StreamWriter(TempStream, Encoding.Unicode))
{
await Writer.WriteAsync(Content.Replace("<FillActualAliasPathInHere>", $"{AliasLocation.Replace(@"\", @"\\")} %1"));
}
}
using (Process Process = Process.Start(TempFile.Path))
{
SetWindowsZPosition(Process);
Process.WaitForExit();
}
Value.Add("Success", string.Empty);
}
else
{
Value.Add("Error", "Alias file is not exists");
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Restore_Win_E":
{
StorageFile RestoreFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Restore_WIN_E.reg"));
using (Process Process = Process.Start(RestoreFile.Path))
{
SetWindowsZPosition(Process);
Process.WaitForExit();
}
ValueSet Value = new ValueSet
{
{ "Success", string.Empty }
};
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_RemoveHiddenAttribute":
{
string ExecutePath = Convert.ToString(args.Request.Message["ExecutePath"]);
if (File.Exists(ExecutePath))
{
File.SetAttributes(ExecutePath, File.GetAttributes(ExecutePath) & ~FileAttributes.Hidden);
}
else if (Directory.Exists(ExecutePath))
{
DirectoryInfo Info = new DirectoryInfo(ExecutePath);
Info.Attributes &= ~FileAttributes.Hidden;
}
ValueSet Value = new ValueSet
{
{ "Success", string.Empty }
};
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_RequestCreateNewPipe":
{
string Guid = Convert.ToString(args.Request.Message["Guid"]);
if (!PipeServers.ContainsKey(Guid))
{
NamedPipeServerStream NewPipeServer = new NamedPipeServerStream($@"Explorer_And_FullTrustProcess_NamedPipe-{Guid}", PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 2048, 2048, null, HandleInheritability.None, PipeAccessRights.ChangePermissions);
PipeSecurity Security = NewPipeServer.GetAccessControl();
PipeAccessRule ClientRule = new PipeAccessRule(new SecurityIdentifier("S-1-15-2-1"), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow);
PipeAccessRule OwnerRule = new PipeAccessRule(WindowsIdentity.GetCurrent().Owner, PipeAccessRights.FullControl, AccessControlType.Allow);
Security.AddAccessRule(ClientRule);
Security.AddAccessRule(OwnerRule);
NewPipeServer.SetAccessControl(Security);
PipeServers.Add(Guid, NewPipeServer);
_ = NewPipeServer.WaitForConnectionAsync(new CancellationTokenSource(3000).Token).ContinueWith((task) =>
{
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipe))
{
Pipe.Dispose();
PipeServers.Remove(Guid);
}
}, TaskContinuationOptions.OnlyOnCanceled);
}
break;
}
case "Identity":
{
ValueSet Value = new ValueSet
{
{ "Identity", "FullTrustProcess" }
};
if (ExplorerProcess != null)
{
Value.Add("PreviousExplorerId", ExplorerProcess.Id);
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Quicklook":
{
string ExecutePath = Convert.ToString(args.Request.Message["ExecutePath"]);
if (!string.IsNullOrEmpty(ExecutePath))
{
QuicklookConnector.SendMessageToQuicklook(ExecutePath);
}
break;
}
case "Execute_Check_QuicklookIsAvaliable":
{
bool IsSuccess = QuicklookConnector.CheckQuicklookIsAvaliable();
ValueSet Result = new ValueSet
{
{ "Check_QuicklookIsAvaliable_Result", IsSuccess }
};
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_Get_Associate":
{
string Path = Convert.ToString(args.Request.Message["ExecutePath"]);
string Associate = ExtensionAssociate.GetAssociate(Path);
ValueSet Result = new ValueSet
{
{ "Associate_Result", Associate }
};
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_Get_RecycleBinItems":
{
ValueSet Result = new ValueSet();
string RecycleItemResult = RecycleBinController.GenerateRecycleItemsByJson();
if (string.IsNullOrEmpty(RecycleItemResult))
{
Result.Add("Error", "Could not get recycle items");
}
else
{
Result.Add("RecycleBinItems_Json_Result", RecycleItemResult);
}
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_Empty_RecycleBin":
{
ValueSet Result = new ValueSet
{
{ "RecycleBinItems_Clear_Result", RecycleBinController.EmptyRecycleBin() }
};
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_Restore_RecycleItem":
{
string Path = Convert.ToString(args.Request.Message["ExecutePath"]);
ValueSet Result = new ValueSet
{
{ "Restore_Result", RecycleBinController.Restore(Path) }
};
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_Delete_RecycleItem":
{
string Path = Convert.ToString(args.Request.Message["ExecutePath"]);
ValueSet Result = new ValueSet
{
{ "Delete_Result", RecycleBinController.Delete(Path) }
};
await args.Request.SendResponseAsync(Result);
break;
}
case "Execute_EjectUSB":
{
ValueSet Value = new ValueSet();
string Path = Convert.ToString(args.Request.Message["ExecutePath"]);
if (string.IsNullOrEmpty(Path))
{
Value.Add("EjectResult", false);
}
else
{
Value.Add("EjectResult", USBController.EjectDevice(Path));
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Unlock_Occupy":
{
ValueSet Value = new ValueSet();
string Path = Convert.ToString(args.Request.Message["ExecutePath"]);
if (File.Exists(Path))
{
if (StorageItemController.CheckOccupied(Path))
{
if (StorageItemController.TryUnoccupied(Path))
{
Value.Add("Success", string.Empty);
}
else
{
Value.Add("Error_Failure", "Unoccupied failed");
}
}
else
{
Value.Add("Error_NotOccupy", "The file is not occupied");
}
}
else
{
Value.Add("Error_NotFoundOrNotFile", "Path is not a file");
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Copy":
{
ValueSet Value = new ValueSet();
string SourcePathJson = Convert.ToString(args.Request.Message["SourcePath"]);
string DestinationPath = Convert.ToString(args.Request.Message["DestinationPath"]);
string Guid = Convert.ToString(args.Request.Message["Guid"]);
bool IsUndo = Convert.ToBoolean(args.Request.Message["Undo"]);
List <KeyValuePair <string, string> > SourcePathList = JsonConvert.DeserializeObject <List <KeyValuePair <string, string> > >(SourcePathJson);
List <string> OperationRecordList = new List <string>();
int Progress = 0;
if (SourcePathList.All((Item) => Directory.Exists(Item.Key) || File.Exists(Item.Key)))
{
if (StorageItemController.CheckPermission(FileSystemRights.Modify, DestinationPath))
{
if (StorageItemController.Copy(SourcePathList, DestinationPath, (s, e) =>
{
lock (Locker)
{
try
{
Progress = e.ProgressPercentage;
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine(e.ProgressPercentage);
}
}
}
catch
{
Debug.WriteLine("Could not send progress data");
}
}
},
(se, arg) =>
{
if (arg.Result == HRESULT.S_OK && !IsUndo)
{
if (arg.DestItem == null || string.IsNullOrEmpty(arg.Name))
{
OperationRecordList.Add($"{arg.SourceItem.FileSystemPath}||Copy||{(Directory.Exists(arg.SourceItem.FileSystemPath) ? "Folder" : "File")}||{Path.Combine(arg.DestFolder.FileSystemPath, arg.SourceItem.Name)}");
}
else
{
OperationRecordList.Add($"{arg.SourceItem.FileSystemPath}||Copy||{(Directory.Exists(arg.SourceItem.FileSystemPath) ? "Folder" : "File")}||{Path.Combine(arg.DestFolder.FileSystemPath, arg.Name)}");
}
}
}))
{
Value.Add("Success", string.Empty);
if (OperationRecordList.Count > 0)
{
Value.Add("OperationRecord", JsonConvert.SerializeObject(OperationRecordList));
}
}
else
{
Value.Add("Error_Failure", "An error occurred while copying the folder");
}
}
else
{
Value.Add("Error_Failure", "An error occurred while copying the folder");
}
}
else
{
Value.Add("Error_NotFound", "SourcePath is not a file or directory");
}
if (Progress < 100)
{
try
{
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine("Error_Stop_Signal");
}
}
}
catch
{
Debug.WriteLine("Could not send stop signal");
}
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Move":
{
ValueSet Value = new ValueSet();
string SourcePathJson = Convert.ToString(args.Request.Message["SourcePath"]);
string DestinationPath = Convert.ToString(args.Request.Message["DestinationPath"]);
string Guid = Convert.ToString(args.Request.Message["Guid"]);
bool IsUndo = Convert.ToBoolean(args.Request.Message["Undo"]);
List <KeyValuePair <string, string> > SourcePathList = JsonConvert.DeserializeObject <List <KeyValuePair <string, string> > >(SourcePathJson);
List <string> OperationRecordList = new List <string>();
int Progress = 0;
if (SourcePathList.All((Item) => Directory.Exists(Item.Key) || File.Exists(Item.Key)))
{
if (SourcePathList.Any((Item) => StorageItemController.CheckOccupied(Item.Key)))
{
Value.Add("Error_Capture", "An error occurred while moving the folder");
}
else
{
if (StorageItemController.CheckPermission(FileSystemRights.Modify, DestinationPath))
{
if (StorageItemController.Move(SourcePathList, DestinationPath, (s, e) =>
{
lock (Locker)
{
try
{
Progress = e.ProgressPercentage;
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine(e.ProgressPercentage);
}
}
}
catch
{
Debug.WriteLine("Could not send progress data");
}
}
},
(se, arg) =>
{
if (arg.Result == HRESULT.COPYENGINE_S_DONT_PROCESS_CHILDREN && !IsUndo)
{
if (arg.DestItem == null || string.IsNullOrEmpty(arg.Name))
{
OperationRecordList.Add($"{arg.SourceItem.FileSystemPath}||Move||{(Directory.Exists(arg.SourceItem.FileSystemPath) ? "Folder" : "File")}||{Path.Combine(arg.DestFolder.FileSystemPath, arg.SourceItem.Name)}");
}
else
{
OperationRecordList.Add($"{arg.SourceItem.FileSystemPath}||Move||{(Directory.Exists(arg.SourceItem.FileSystemPath) ? "Folder" : "File")}||{Path.Combine(arg.DestFolder.FileSystemPath, arg.Name)}");
}
}
}))
{
Value.Add("Success", string.Empty);
if (OperationRecordList.Count > 0)
{
Value.Add("OperationRecord", JsonConvert.SerializeObject(OperationRecordList));
}
}
else
{
Value.Add("Error_Failure", "An error occurred while moving the folder");
}
}
else
{
Value.Add("Error_Failure", "An error occurred while moving the folder");
}
}
}
else
{
Value.Add("Error_NotFound", "SourcePath is not a file or directory");
}
if (Progress < 100)
{
try
{
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine("Error_Stop_Signal");
}
}
}
catch
{
Debug.WriteLine("Could not send progress data");
}
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Delete":
{
ValueSet Value = new ValueSet();
string ExecutePathJson = Convert.ToString(args.Request.Message["ExecutePath"]);
string Guid = Convert.ToString(args.Request.Message["Guid"]);
bool PermanentDelete = Convert.ToBoolean(args.Request.Message["PermanentDelete"]);
bool IsUndo = Convert.ToBoolean(args.Request.Message["Undo"]);
List <string> ExecutePathList = JsonConvert.DeserializeObject <List <string> >(ExecutePathJson);
List <string> OperationRecordList = new List <string>();
int Progress = 0;
try
{
if (ExecutePathList.All((Item) => Directory.Exists(Item) || File.Exists(Item)))
{
if (ExecutePathList.Any((Item) => StorageItemController.CheckOccupied(Item)))
{
Value.Add("Error_Capture", "An error occurred while deleting the folder");
}
else
{
if (ExecutePathList.All((Path) => (Directory.Exists(Path) || File.Exists(Path)) && StorageItemController.CheckPermission(FileSystemRights.Modify, System.IO.Path.GetDirectoryName(Path))))
{
if (StorageItemController.Delete(ExecutePathList, PermanentDelete, (s, e) =>
{
lock (Locker)
{
try
{
Progress = e.ProgressPercentage;
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine(e.ProgressPercentage);
}
}
}
catch
{
Debug.WriteLine("Could not send progress data");
}
}
},
(se, arg) =>
{
if (!PermanentDelete && !IsUndo)
{
OperationRecordList.Add($"{arg.SourceItem.FileSystemPath}||Delete");
}
}))
{
Value.Add("Success", string.Empty);
if (OperationRecordList.Count > 0)
{
Value.Add("OperationRecord", JsonConvert.SerializeObject(OperationRecordList));
}
}
else
{
Value.Add("Error_Failure", "The specified file could not be deleted");
}
}
else
{
Value.Add("Error_Failure", "The specified file could not be deleted");
}
}
}
else
{
Value.Add("Error_NotFound", "ExecutePath is not a file or directory");
}
}
catch
{
Value.Add("Error_Failure", "The specified file or folder could not be deleted");
}
if (Progress < 100)
{
try
{
if (PipeServers.TryGetValue(Guid, out NamedPipeServerStream Pipeline))
{
using (StreamWriter Writer = new StreamWriter(Pipeline, new UTF8Encoding(false), 1024, true))
{
Writer.WriteLine("Error_Stop_Signal");
}
}
}
catch
{
Debug.WriteLine("Could not send stop signal");
}
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_RunExe":
{
string ExecutePath = Convert.ToString(args.Request.Message["ExecutePath"]);
string ExecuteParameter = Convert.ToString(args.Request.Message["ExecuteParameter"]);
string ExecuteAuthority = Convert.ToString(args.Request.Message["ExecuteAuthority"]);
bool ExecuteCreateNoWindow = Convert.ToBoolean(args.Request.Message["ExecuteCreateNoWindow"]);
ValueSet Value = new ValueSet();
if (!string.IsNullOrEmpty(ExecutePath))
{
if (StorageItemController.CheckPermission(FileSystemRights.ReadAndExecute, ExecutePath))
{
if (string.IsNullOrEmpty(ExecuteParameter))
{
using (Process Process = new Process())
{
Process.StartInfo.FileName = ExecutePath;
Process.StartInfo.UseShellExecute = true;
Process.StartInfo.CreateNoWindow = ExecuteCreateNoWindow;
Process.StartInfo.WorkingDirectory = Path.GetDirectoryName(ExecutePath);
if (ExecuteAuthority == "Administrator")
{
Process.StartInfo.Verb = "runAs";
}
Process.Start();
SetWindowsZPosition(Process);
}
}
else
{
using (Process Process = new Process())
{
Process.StartInfo.FileName = ExecutePath;
Process.StartInfo.Arguments = ExecuteParameter;
Process.StartInfo.UseShellExecute = true;
Process.StartInfo.CreateNoWindow = ExecuteCreateNoWindow;
Process.StartInfo.WorkingDirectory = Path.GetDirectoryName(ExecutePath);
if (ExecuteAuthority == "Administrator")
{
Process.StartInfo.Verb = "runAs";
}
Process.Start();
SetWindowsZPosition(Process);
}
}
Value.Add("Success", string.Empty);
}
else
{
Value.Add("Error_Failure", "The specified file could not be executed");
}
}
else
{
Value.Add("Success", string.Empty);
}
await args.Request.SendResponseAsync(Value);
break;
}
case "Execute_Test_Connection":
{
try
{
if (args.Request.Message.TryGetValue("ProcessId", out object Obj) && Obj is int Id && ExplorerProcess?.Id != Id)
{
ExplorerProcess?.Dispose();
ExplorerProcess = Process.GetProcessById(Id);
}
}
catch
{
Debug.WriteLine("GetProcess from id and register Exit event failed");
}
await args.Request.SendResponseAsync(new ValueSet { { "Execute_Test_Connection", string.Empty } });
break;
}
case "Execute_Exit":
{
ExitLocker.Set();
break;
}
}
}
catch (Exception ex)
{
ValueSet Value = new ValueSet
{
{ "Error", ex.Message }
};
await args.Request.SendResponseAsync(Value);
}
finally
{
Deferral.Complete();
}
}
private static async void HandleApplicationLaunch(string application, AppServiceRequestReceivedEventArgs args)
{
var arguments = args.Request.Message.Get("Arguments", "");
var workingDirectory = args.Request.Message.Get("WorkingDirectory", "");
try
{
Process process = new Process();
process.StartInfo.UseShellExecute = false;
process.StartInfo.FileName = application;
// Show window if workingDirectory (opening terminal)
process.StartInfo.CreateNoWindow = string.IsNullOrEmpty(workingDirectory);
if (arguments == "runas")
{
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runas";
if (Path.GetExtension(application).ToLower() == ".msi")
{
process.StartInfo.FileName = "msiexec.exe";
process.StartInfo.Arguments = $"/a \"{application}\"";
}
}
else if (arguments == "runasuser")
{
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runasuser";
if (Path.GetExtension(application).ToLower() == ".msi")
{
process.StartInfo.FileName = "msiexec.exe";
process.StartInfo.Arguments = $"/i \"{application}\"";
}
}
else
{
process.StartInfo.Arguments = arguments;
}
process.StartInfo.WorkingDirectory = workingDirectory;
process.Start();
}
catch (Win32Exception)
{
Process process = new Process();
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runas";
process.StartInfo.FileName = application;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.Arguments = arguments;
process.StartInfo.WorkingDirectory = workingDirectory;
try
{
process.Start();
}
catch (Win32Exception)
{
try
{
await Win32API.StartSTATask(() =>
{
var split = application.Split('|').Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => GetMtpPath(x));
if (split.Count() == 1)
{
Process.Start(split.First());
}
else
{
var groups = split.GroupBy(x => new
{
Dir = Path.GetDirectoryName(x),
Prog = Win32API.GetFileAssociation(x).Result ?? Path.GetExtension(x)
});
foreach (var group in groups)
{
if (!group.Any())
{
continue;
}
using var cMenu = Win32API.ContextMenu.GetContextMenuForFiles(group.ToArray(), Shell32.CMF.CMF_DEFAULTONLY);
cMenu?.InvokeVerb(Shell32.CMDSTR_OPEN);
}
}
return(true);
});
}
catch (Win32Exception)
{
// Cannot open file (e.g DLL)
}
catch (ArgumentException)
{
// Cannot open file (e.g DLL)
}
}
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var messageType = (byte)args.Request.Message[MessageKeys.Type];
switch (messageType)
{
case WriteDataMessageIdentifier:
HandleWriteDataMessage(args);
break;
case CreateTerminalRequest.Identifier:
await HandleCreateTerminalRequest(args);
break;
case ResizeTerminalRequest.Identifier:
HandleResizeTerminalRequest(args);
break;
case SetToggleWindowKeyBindingsRequest.Identifier:
HandleSetToggleWindowKeyBindingsRequest(args);
break;
case TerminalExitedRequest.Identifier:
HandleTerminalExitedRequest(args);
break;
case GetAvailablePortRequest.Identifier:
await HandleGetAvailablePortRequest(args);
break;
case GetUserNameRequest.Identifier:
await HandleGetUserNameRequest(args);
break;
case SaveTextFileRequest.Identifier:
await HandleSaveTextFileRequest(args);
break;
case GetSshConfigFolderRequest.Identifier:
await HandleGetSshConfigFolderRequest(args);
break;
case CheckFileExistsRequest.Identifier:
await HandleCheckFileExistsRequest(args);
break;
case MuteTerminalRequest.Identifier:
await HandleMuteTerminalRequest(args);
break;
case UpdateSettingsRequest.Identifier:
await HandleUpdateSettingsRequest(args);
break;
default:
Logger.Instance.Error("Received unknown message type: {messageType}", messageType);
break;
}
}
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.GitX.UI.Test");
returnData.Add("sketch-home", "X.Extension.ThirdParty.GitX.UI.Home");
break;
}
await args.Request.SendResponseAsync(returnData);
msgDef.Complete();
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var requestDeferral = args.GetDeferral();
try
{
Debug.WriteLine("A request received");
if (args.Request.Message.ContainsKey("Receiver"))
{
string receiver = args.Request.Message["Receiver"] as string;
Debug.WriteLine($"Receiver is {receiver}");
Dictionary <string, object> reqMessage = new Dictionary <string, object>();
foreach (var item in args.Request.Message)
{
reqMessage.Add(item.Key, item.Value);
}
if (receiver == "ServerIPFinder")
{
await FileTransfer.ServerIPFinder.ReceiveRequest(reqMessage);
}
else if (receiver == "FileReceiver")
{
await FileTransfer.FileReceiver.ReceiveRequest(reqMessage, DownloadFolderDecider);
}
else if (receiver == "TextReceiver")
{
await TextTransfer.TextReceiver.ReceiveRequest(reqMessage);
}
else if (receiver == "CloudClipboardHandler")
{
CloudClipboardHandler.ReceiveRequest(reqMessage);
_appServiceconnection.Dispose();
_deferral?.Complete();
_deferral = null;
}
else if (receiver == "System")
{
if (args.Request.Message.ContainsKey("FinishService"))
{
if (_deferral != null)
{
System.Diagnostics.Debug.WriteLine("Let's say goodbye");
while (waitingNumSemaphore > 0)
{
await Task.Delay(100);
}
System.Diagnostics.Debug.WriteLine("Goodbye");
_appServiceconnection.Dispose();
_deferral?.Complete();
_deferral = null;
}
}
//else if ((args.Request.Message.ContainsKey("Task")) && (args.Request.Message["Task"] as string == "MessageCarrier"))
//{
//}
}
}
//else if (args.Request.Message.ContainsKey("Test"))
//{
// string s = args.Request.Message["Test"] as string;
// if (s == null)
// s = "null";
// ValueSet vs = new ValueSet();
// vs.Add("RecvSuccessful", "RecvSuccessful");
// await args.Request.SendResponseAsync(vs);
// await System.Threading.Tasks.Task.Delay(1500);
// SendToast(s);
//}
//else if (args.Request.Message.ContainsKey("TestLongRunning"))
//{
// for (int i = 0; i < 10000; i++)
// {
// SendToast((i).ToString() + " seconds");
// await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(1));
// }
//}
}
finally
{
requestDeferral?.Complete();
}
}
protected virtual void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
}
private static void HandleApplicationsLaunch(IEnumerable <string> applications, AppServiceRequestReceivedEventArgs args)
{
foreach (var application in applications)
{
HandleApplicationLaunch(application, args);
}
}
private static async void HandleApplicationLaunch(string application, AppServiceRequestReceivedEventArgs args)
{
var arguments = args.Request.Message.Get("Arguments", "");
var workingDirectory = args.Request.Message.Get("WorkingDirectory", "");
try
{
Process process = new Process();
process.StartInfo.UseShellExecute = false;
process.StartInfo.FileName = application;
// Show window if workingDirectory (opening terminal)
process.StartInfo.CreateNoWindow = string.IsNullOrEmpty(workingDirectory);
if (arguments == "runas")
{
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runas";
if (Path.GetExtension(application).ToLower() == ".msi")
{
process.StartInfo.FileName = "msiexec.exe";
process.StartInfo.Arguments = $"/a \"{application}\"";
}
}
else if (arguments == "runasuser")
{
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runasuser";
if (Path.GetExtension(application).ToLower() == ".msi")
{
process.StartInfo.FileName = "msiexec.exe";
process.StartInfo.Arguments = $"/i \"{application}\"";
}
}
else
{
process.StartInfo.Arguments = arguments;
}
process.StartInfo.WorkingDirectory = workingDirectory;
process.Start();
}
catch (Win32Exception)
{
Process process = new Process();
process.StartInfo.UseShellExecute = true;
process.StartInfo.Verb = "runas";
process.StartInfo.FileName = application;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.Arguments = arguments;
process.StartInfo.WorkingDirectory = workingDirectory;
try
{
process.Start();
}
catch (Win32Exception)
{
try
{
await Win32API.StartSTATask(() =>
{
var split = application.Split(';').Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => GetMtpPath(x));
if (split.Count() == 1)
{
Process.Start(split.First());
}
else
{
var groups = split.GroupBy(x => new
{
Dir = Path.GetDirectoryName(x),
Prog = Win32API.GetFileAssociation(x).Result ?? Path.GetExtension(x)
});
foreach (var group in groups)
{
if (!group.Any())
{
continue;
}
var files = group.Select(x => new ShellItem(x));
using var sf = files.First().Parent;
Shell32.IContextMenu menu = null;
try
{
menu = sf.GetChildrenUIObjects <Shell32.IContextMenu>(null, files.ToArray());
menu.QueryContextMenu(HMENU.NULL, 0, 0, 0, Shell32.CMF.CMF_DEFAULTONLY);
var pici = new Shell32.CMINVOKECOMMANDINFOEX();
pici.lpVerb = Shell32.CMDSTR_OPEN;
pici.nShow = ShowWindowCommand.SW_SHOW;
pici.cbSize = (uint)Marshal.SizeOf(pici);
menu.InvokeCommand(pici);
}
finally
{
foreach (var elem in files)
{
elem.Dispose();
}
if (menu != null)
{
Marshal.ReleaseComObject(menu);
}
}
}
}
return(true);
});
}
catch (Win32Exception)
{
// Cannot open file (e.g DLL)
}
catch (ArgumentException)
{
// Cannot open file (e.g DLL)
}
}
}
}
private static async Task parseRecycleBinAction(AppServiceRequestReceivedEventArgs args, string action)
{
switch (action)
{
case "Empty":
// Shell function to empty recyclebin
Shell32.SHEmptyRecycleBin(IntPtr.Zero, null, Shell32.SHERB.SHERB_NOCONFIRMATION | Shell32.SHERB.SHERB_NOPROGRESSUI);
break;
case "Query":
var responseQuery = new ValueSet();
Shell32.SHQUERYRBINFO queryBinInfo = new Shell32.SHQUERYRBINFO();
queryBinInfo.cbSize = (uint)Marshal.SizeOf(queryBinInfo);
var res = Shell32.SHQueryRecycleBin(null, ref queryBinInfo);
if (res == HRESULT.S_OK)
{
var numItems = queryBinInfo.i64NumItems;
var binSize = queryBinInfo.i64Size;
responseQuery.Add("NumItems", numItems);
responseQuery.Add("BinSize", binSize);
await args.Request.SendResponseAsync(responseQuery);
}
break;
case "Enumerate":
// Enumerate recyclebin contents and send response to UWP
var responseEnum = new ValueSet();
var folderContentsList = new List <ShellFileItem>();
foreach (var folderItem in recycler)
{
try
{
string recyclePath = folderItem.FileSystemPath; // True path on disk
string fileName = Path.GetFileName(folderItem.Name); // Original file name
string filePath = folderItem.Name; // Original file path + name
bool isFolder = folderItem.IsFolder && Path.GetExtension(folderItem.Name) != ".zip";
if (folderItem.Properties == null)
{
folderContentsList.Add(new ShellFileItem(isFolder, recyclePath, fileName, filePath, DateTime.Now, null, 0, null));
continue;
}
folderItem.Properties.TryGetValue <System.Runtime.InteropServices.ComTypes.FILETIME?>(
Ole32.PROPERTYKEY.System.DateCreated, out var fileTime);
var recycleDate = fileTime?.ToDateTime().ToLocalTime() ?? DateTime.Now; // This is LocalTime
string fileSize = folderItem.Properties.TryGetValue <ulong?>(
Ole32.PROPERTYKEY.System.Size, out var fileSizeBytes) ?
folderItem.Properties.GetPropertyString(Ole32.PROPERTYKEY.System.Size) : null;
folderItem.Properties.TryGetValue <string>(
Ole32.PROPERTYKEY.System.ItemTypeText, out var fileType);
folderContentsList.Add(new ShellFileItem(isFolder, recyclePath, fileName, filePath, recycleDate, fileSize, fileSizeBytes ?? 0, fileType));
}
catch (FileNotFoundException)
{
// Happens if files are being deleted
}
finally
{
folderItem.Dispose();
}
}
responseEnum.Add("Enumerate", JsonConvert.SerializeObject(folderContentsList));
await args.Request.SendResponseAsync(responseEnum);
break;
default:
break;
}
}
private static async Task parseArguments(AppServiceRequestReceivedEventArgs args, AppServiceDeferral messageDeferral, string arguments, ApplicationDataContainer localSettings)
{
switch (arguments)
{
case "Terminate":
// Exit fulltrust process (UWP is closed or suspended)
appServiceExit.Set();
messageDeferral.Complete();
break;
case "RecycleBin":
var binAction = (string)args.Request.Message["action"];
await parseRecycleBinAction(args, binAction);
break;
case "StartupTasks":
// Check QuickLook Availability
QuickLook.CheckQuickLookAvailability(localSettings);
break;
case "ToggleQuickLook":
var path = (string)args.Request.Message["path"];
QuickLook.ToggleQuickLook(path);
break;
case "ShellCommand":
// Kill the process. This is a BRUTAL WAY to kill a process.
#if DEBUG
// In debug mode this kills this process too??
#else
var pid = (int)args.Request.Message["pid"];
Process.GetProcessById(pid).Kill();
#endif
Process process = new Process();
process.StartInfo.UseShellExecute = true;
process.StartInfo.FileName = "explorer.exe";
process.StartInfo.CreateNoWindow = false;
process.StartInfo.Arguments = (string)args.Request.Message["ShellCommand"];
process.Start();
break;
case "LoadMUIVerb":
var responseSet = new ValueSet();
responseSet.Add("MUIVerbString", Win32API.ExtractStringFromDLL((string)args.Request.Message["MUIVerbLocation"], (int)args.Request.Message["MUIVerbLine"]));
await args.Request.SendResponseAsync(responseSet);
break;
case "ParseAguments":
var responseArray = new ValueSet();
var resultArgument = Win32API.CommandLineToArgs((string)args.Request.Message["Command"]);
responseArray.Add("ParsedArguments", JsonConvert.SerializeObject(resultArgument));
await args.Request.SendResponseAsync(responseArray);
break;
case "Bitlocker":
var bitlockerAction = (string)args.Request.Message["action"];
if (bitlockerAction == "Unlock")
{
var drive = (string)args.Request.Message["drive"];
var password = (string)args.Request.Message["password"];
Win32API.UnlockBitlockerDrive(drive, password);
await args.Request.SendResponseAsync(new ValueSet()
{
{ "Bitlocker", "Unlock" }
});
}
break;
default:
if (args.Request.Message.ContainsKey("Application"))
{
var application = (string)args.Request.Message["Application"];
HandleApplicationLaunch(application, args);
}
else if (args.Request.Message.ContainsKey("ApplicationList"))
{
var applicationList = JsonConvert.DeserializeObject <IEnumerable <string> >((string)args.Request.Message["ApplicationList"]);
HandleApplicationsLaunch(applicationList, args);
}
break;
}
}
private static 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();
if (args.Request.Message == null)
{
messageDeferral.Complete();
return;
}
try
{
if (args.Request.Message.ContainsKey("Arguments"))
{
// This replaces launching the fulltrust process with arguments
// Instead a single instance of the process is running
// Requests from UWP app are sent via AppService connection
var arguments = (string)args.Request.Message["Arguments"];
var localSettings = ApplicationData.Current.LocalSettings;
Logger.Info($"Argument: {arguments}");
await parseArguments(args, messageDeferral, arguments, localSettings);
}
else if (args.Request.Message.ContainsKey("Application"))
{
var application = (string)args.Request.Message["Application"];
HandleApplicationLaunch(application, args);
}
else if (args.Request.Message.ContainsKey("ApplicationList"))
{
var applicationList = JsonConvert.DeserializeObject <IEnumerable <string> >((string)args.Request.Message["ApplicationList"]);
HandleApplicationsLaunch(applicationList, args);
}
}
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 void AppServiceConnection_RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
void setText()
{
logTextBlock.Text = (string)args.Request.Message["Now"];
}
if (Dispatcher.CheckAccess())
{
setText();
}
else
{
Dispatcher.Invoke(() => setText());
}
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var messageDeferral = args.GetDeferral();
ValueSet returnData = new ValueSet();
try
{
var vault = new PasswordVault();
var list = vault.FindAllByResource("Lastfmapp");
var item = list[0];
item.RetrievePassword();
ValueSet message = args.Request.Message;
string song = message["Song"] as string;
string album = message["Album"] as string;
string artist = message["Artist"] as string;
// KoScrobbler: https://www.nuget.org/packages/KoScrobbler
KoScrobbler.Scrobbler scrobbler = new KoScrobbler.Scrobbler(Lastfm apikey, lastfm apisecret);
var x = await scrobbler.CreateSessionAsync(item.UserName, item.Password);
var key = x.SessionKey;
var session1 = await scrobbler.ValidateSessionAsync(item.UserName, key);
var blaah = new List <KoScrobbler.Entities.Scrobble>();
blaah.Add(new KoScrobbler.Entities.Scrobble(artist, album, song, DateTime.Now));
var scrobble = await scrobbler.ScrobbleAsync(blaah);
if (scrobble.Success)
{
string toast = $@"<toast>
<visual>
<binding template='ToastGeneric'>
<text>Last.FM</text>
<text>Track successfully scrobbled.</text>
<image placement='appLogoOverride' hint-crop='circle' src='ms-appx:///Assets/checkmark.png'/>
</binding>
</visual>
</toast>";
Windows.Data.Xml.Dom.XmlDocument doc = new Windows.Data.Xml.Dom.XmlDocument();
doc.LoadXml(toast);
var toastNotif = new ToastNotification(doc);
// And send the notification
ToastNotificationManager.CreateToastNotifier().Show(toastNotif);
returnData.Add("Status", "OK");
}
try
{
await args.Request.SendResponseAsync(returnData); // Return the data to the caller.
}
catch (Exception e)
{
// your exception handling code here
}
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();
}
}
catch (Exception ex)
{
string toast = $@"<toast>
<visual>
<binding template='ToastGeneric'>
<text>Last.FM</text>
<text>{ex.Message}</text>
<image placement='appLogoOverride' hint-crop='circle' src='ms-appx:///Assets/xmark.png'/>
</binding>
</visual>
</toast>";
Windows.Data.Xml.Dom.XmlDocument doc = new Windows.Data.Xml.Dom.XmlDocument();
doc.LoadXml(toast);
var toastNotif = new ToastNotification(doc);
// And send the notification
ToastNotificationManager.CreateToastNotifier().Show(toastNotif);
returnData.Add("Status", "Fail: Index out of range");
}
try
{
await args.Request.SendResponseAsync(returnData); // Return the data to the caller.
}
catch (Exception e)
{
// your exception handling code here
}
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();
}
}
