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 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(); }
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(); } }