Пример #1
1
		private async void LaunchUriForResult_Click(object sender, RoutedEventArgs e)
		{
			var protocol = "win10demo2://";
			var packageFamilyName = "0df93276-6bbb-46fa-96b7-ec223e226505_cb1hhkscw5m06";
			var status = await Launcher.QueryUriSupportAsync(new Uri(protocol), LaunchQuerySupportType.UriForResults, packageFamilyName);
			if (status == LaunchQuerySupportStatus.Available)
			{
				var options = new LauncherOptions
				{
					TargetApplicationPackageFamilyName = packageFamilyName
				};
				var values = new ValueSet();
				values.Add("TwitterId", "danvy");
				var result = await Launcher.LaunchUriForResultsAsync(new Uri(protocol), options, values);
				if (result.Status == LaunchUriStatus.Success)
				{
					var authorized = result.Result["Authorized"] as string;
					if (authorized == true.ToString())
					{
						var dialog = new MessageDialog("You are authorized :)");
						await dialog.ShowAsync();
					}
				}
			}
		}
Пример #2
0
		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();
		}
Пример #3
0
        public async Task<IEnumerable<Beer>> GetBeersByFilter(string filter)
        {
            AppServiceConnection connection = new AppServiceConnection();
            connection.AppServiceName = "PlainConcepts-appservicesdemo";
            connection.PackageFamilyName = "cff6d46b-5839-4bb7-a1f2-e59246de63b3_cb1hhkscw5m06";
            AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();

            if (connectionStatus == AppServiceConnectionStatus.Success)
            {
                //Send data to the service
                var message = new ValueSet();
                message.Add("Command", "GetBeersByFilter");
                message.Add("Filter", filter);

                //Send message and wait for response   
                AppServiceResponse response = await connection.SendMessageAsync(message);
                if (response.Status == AppServiceResponseStatus.Success)
                {
                    var resultJson = (string)response.Message["Result"];
                    var list = JsonConvert.DeserializeObject<IEnumerable<Beer>>(resultJson);
                    return list;
                }
            }
            else
            {
                //Drive the user to store to install the app that provides the app service 
                new MessageDialog("Service not installed").ShowAsync();
            }

            return null;
        }
Пример #4
0
        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();
        }
Пример #5
0
 private async void SendMessageToServer(string message)
 {
     var command = new ValueSet();
     command.Add("Command", "Bridge");
     command.Add("SendToServer", message);
     var response = await _appServiceConnection.SendMessageAsync(command);
 }
        private async Task NotifyClientsOfPerimeterState()
        {
            var _sensorCurrentValue = _sensorPin.Read();
            var messages = new ValueSet(); //name value pair

            if (_sensorCurrentValue == GpioPinValue.High)
            {
                //send perimeter breached
                messages.Add("Perimeter Notification", "Breached");
            }
            else
            {
                //send perimeter secure
                messages.Add("Perimeter Notification", "Secure");
            }

            //send message to the client
            var response = await _connection.SendMessageAsync(messages);

            if (response.Status == AppServiceResponseStatus.Success)
            {
                var result = response.Message["Response"];
                //optionally log result from client
            }
        }
 public async void PostBookAsync()
 {
     var message = new ValueSet();
     message.Add("command", "POST");
     string json = new Book { Title = NewBookTitle, Publisher = NewBookPublisher }.ToJson();
     message.Add("book", json);
     string result = await SendMessageAsync(message);
 }
Пример #8
0
        public static ValueSet ConstructMessage(string tag, string content)
        {
            var valueSet = new ValueSet();
            valueSet.Add(MessageTag, tag);
            valueSet.Add(MessageContent, content);

            return valueSet;
        }
Пример #9
0
    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;
          }
      }
    }
Пример #10
0
		private void ReturnResult()
		{
			if (pfrArgs != null)
			{
				var values = new ValueSet();
				values.Add("TimeStamp", DateTime.Now.ToString());
				values.Add("Authorized", (IdBlock.Text == "danvy").ToString());
				pfrArgs.ProtocolForResultsOperation.ReportCompleted(values);
			}
		}
Пример #11
0
        private async void OnOpenAnotherAppWithDataClicked(object sender, RoutedEventArgs e)
        {
            LauncherOptions options = new LauncherOptions();
            options.TargetApplicationPackageFamilyName = "8a1341de-3acd-4d5a-91f2-98d9cd2c1c6e_e8f4dqfvn1be6";

            ValueSet data = new ValueSet();
            data.Add("Customer", "Contoso");
            data.Add("Price", "25");

            await Launcher.LaunchUriAsync(new Uri("invoice:"), options, data);
        }
        public async Task<IEnumerable<FeedItem>> GetNewsAsync(string url)
        {
            AppServiceConnection connection = new AppServiceConnection();
            connection.PackageFamilyName = "637bc306-acb1-4e73-bbe0-70ecc919ca1c_e8f4dqfvn1be6";
            connection.AppServiceName = "FeedParser";

            var status = await connection.OpenAsync();

            if (status == AppServiceConnectionStatus.Success)
            {
                ValueSet data = new ValueSet();
                data.Add("FeedUrl", url);

                var response = await connection.SendMessageAsync(data);
                if (response.Status == AppServiceResponseStatus.Success)
                {
                    string items = response.Message["FeedItems"].ToString();
                    var result = JsonConvert.DeserializeObject<List<FeedItem>>(items);
                    return result;
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
        }
 private ValueSet AddBook(string book)
 {
     BooksRepository.Instance.AddBook(book.ToBook());
     var result = new ValueSet();
     result.Add("result", "ok");
     return result;
 }
Пример #14
0
        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;
                    }
            }
        }
Пример #15
0
        private async void pickerBtb_Click(object sender, RoutedEventArgs e)
        {
            //Set a result to return to the caller
            var returnMessage = new ValueSet();
            server = new HttpServer(8080);
            server.StartServer();
            returnMessage.Add("Status", "Success");

            // var myPictures = await StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures);
            var picker = new Windows.Storage.Pickers.FileOpenPicker();
            picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
            picker.FileTypeFilter.Add(".jpg");
            picker.FileTypeFilter.Add(".jpeg");
            picker.FileTypeFilter.Add(".png");

            StorageFile file = await picker.PickSingleFileAsync();
            if (file != null)
            {
                // Application now has read/write access to the picked file
                Log("Picked photo: " + file.Path, "Success");
                server.FilePath = file.Path;
            }
            else
            {
                Log("Operation cancelled.", "Error");
            }
        }
Пример #16
0
        private async void GetEmployeeById(object sender, RoutedEventArgs e)
        {

            appServiceConnection = new AppServiceConnection
            {
                AppServiceName = "EmployeeLookupService",
                PackageFamilyName = "3598a822-2b34-44cc-9a20-421137c7511f_4frctqp64dy5c"
            };

            var status = await appServiceConnection.OpenAsync();

            switch (status)
            {
                case AppServiceConnectionStatus.AppNotInstalled:
                    await LogError("The EmployeeLookup application is not installed. Please install it and try again.");
                    return;
                case AppServiceConnectionStatus.AppServiceUnavailable:
                    await LogError("The EmployeeLookup application does not have the available feature");
                    return;
                case AppServiceConnectionStatus.AppUnavailable:
                    await LogError("The package for the app service to which a connection was attempted is unavailable.");
                    return;
                case AppServiceConnectionStatus.Unknown:
                    await LogError("Unknown Error.");
                    return;
            }

            var items = this.EmployeeId.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            var message = new ValueSet();

            for (int i = 0; i < items.Length; i++)
            {
                message.Add(i.ToString(), items[i]);
            }

            var response = await appServiceConnection.SendMessageAsync(message);

            switch (response.Status)
            {
                case AppServiceResponseStatus.ResourceLimitsExceeded:
                    await LogError("Insufficient resources. The app service has been shut down.");
                    return;
                case AppServiceResponseStatus.Failure:
                    await LogError("Failed to receive response.");
                    return;
                case AppServiceResponseStatus.Unknown:
                    await LogError("Unknown error.");
                    return;
            }

            foreach (var item in response.Message)
            {
                this.Items.Add(new Employee
                {
                    Id = item.Key,
                    Name = item.Value.ToString()
                });
            }
        }
Пример #17
0
		private async void CallService_Click(object sender, RoutedEventArgs e)
		{
			var connection = new AppServiceConnection();
			connection.PackageFamilyName = "0df93276-6bbb-46fa-96b7-ec223e226505_cb1hhkscw5m06"; // Windows.ApplicationModel.Package.Current.Id.FamilyName;
			connection.AppServiceName = "CalculatorService";
			var status = await connection.OpenAsync();
			if (status != AppServiceConnectionStatus.Success)
			{
				var dialog = new MessageDialog("Sorry, I can't connect to the service right now :S");
				await dialog.ShowAsync();
				return;
			}
			var message = new ValueSet();
			message.Add("service", OperatorCombo.Items[OperatorCombo.SelectedIndex]);
			message.Add("a", Convert.ToInt32(ValueABox.Text));
			message.Add("b", Convert.ToInt32(ValueBBox.Text));
			AppServiceResponse response = await connection.SendMessageAsync(message);
			if (response.Status == AppServiceResponseStatus.Success)
			{
				if (response.Message.ContainsKey("result"))
				{
					ResultBlock.Text = response.Message["result"] as string;
				}
			}
			else
			{
				var dialog = new MessageDialog(string.Format("Opps, I just get an error :S ({0})", response.Status));
				await dialog.ShowAsync();
			}
		}
Пример #18
0
		private async void CallService_Click(object sender, RoutedEventArgs e)
		{
			var connection = new AppServiceConnection();
			connection.PackageFamilyName = "041cdcf9-8ef3-40e4-85e2-8f3de5e06155_ncrzdc1cmma1g"; // Windows.ApplicationModel.Package.Current.Id.FamilyName;
			connection.AppServiceName = "CalculatorService";
			var status = await connection.OpenAsync();
			if (status != AppServiceConnectionStatus.Success)
			{
				var dialog = new MessageDialog("Sorry, I can't connect to the service right now :S");
				await dialog.ShowAsync();
				return;
			}
			var message = new ValueSet();
			message.Add("service", (OperatorCombo.SelectedValue as ComboBoxItem).Content);
			message.Add("a", Convert.ToInt32(ValueABox.Text));
			message.Add("b", Convert.ToInt32(ValueBBox.Text));
			AppServiceResponse response = await connection.SendMessageAsync(message);
			if (response.Status == AppServiceResponseStatus.Success)
			{
				if (response.Message.ContainsKey("result"))
				{
					ResultBlock.Text = response.Message["result"].ToString();
				}
			}
			else
			{
				var dialog = new MessageDialog(string.Format("Opps, I just get an error :S ({0})", response.Status));
				await dialog.ShowAsync();
			}
		}
Пример #19
0
		private async void LaunchUriForResult_Click(object sender, RoutedEventArgs e)
		{
			var protocol = "win10demo2://";
			var packageFamilyName = "041cdcf9-8ef3-40e4-85e2-8f3de5e06155_ncrzdc1cmma1g";
			var status = await Launcher.QueryUriSupportAsync(new Uri(protocol), LaunchQuerySupportType.UriForResults, packageFamilyName);
			if (status == LaunchQuerySupportStatus.Available)
			{
				var options = new LauncherOptions
				{
					TargetApplicationPackageFamilyName = packageFamilyName
				};
				var values = new ValueSet();
				values.Add("TwitterId", "danvy");
				var result = await Launcher.LaunchUriForResultsAsync(new Uri(protocol), options, values);
				if ((result.Status == LaunchUriStatus.Success) && (result.Result != null))
				{
					var authorized = result.Result["Authorized"] as string;
					if (authorized == true.ToString())
					{
						var dialog = new MessageDialog("You are authorized :)");
						await dialog.ShowAsync();
					}
				}
			}
		}
Пример #20
0
        private async void OnPlayClick(object sender, RoutedEventArgs e)
        {
            String url = txtURL.Text;
            String tag = "ra000001";
            Uri hsl = await GetHitChannelHSL(url, tag);
            if (hsl != null)
            {
                // check is phone
                bool isHardwareButtonsAPIPresent =
        Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons");

                if (isHardwareButtonsAPIPresent)
                {
                    //Windows.Phone.UI.Input.HardwareButtons.CameraPressed +=
                    //    HardwareButtons_CameraPressed;
                    ValueSet msg = new ValueSet();
                    msg.Add("Play", hsl.OriginalString);
                    BackgroundMediaPlayer.SendMessageToBackground(msg);
                }

                AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(hsl);
                if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
                {
                    _source = result.MediaSource;
                    _source.DownloadRequested += _source_DownloadRequested;
                    _source.DownloadCompleted += _source_DownloadCompleted;
                    _source.DownloadFailed += _source_DownloadFailed;
                    _source.DownloadBitrateChanged += _source_DownloadBitrateChanged;
                    _source.PlaybackBitrateChanged += _source_PlaybackBitrateChanged;

                    mediaPlayer.SetMediaStreamSource(result.MediaSource);
                }
            }
        }
Пример #21
0
        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;
            }
        }
Пример #22
0
        /// <summary>
        /// Hệ thống gọi đến hàm này khi association backgroundtask được bật
        /// </summary>
        /// <param name="taskInstance"> hệ thống tự tạo và truyền vào đây</param>
        public async void Run(IBackgroundTaskInstance taskInstance)
        {
            //System.Diagnostics.Debug.WriteLine("background run");
            taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(BackgroundTaskCanceled);
            taskInstance.Task.Completed += new BackgroundTaskCompletedEventHandler(BackgroundTaskCompleted);
            _backgroundstarted.Set();//
            _deferral = taskInstance.GetDeferral();

            //Playlist = new BackgroundPlaylist();
            _smtc = initSMTC();


            this._foregroundState = this.initForegroundState();

            BackgroundMediaPlayer.Current.CurrentStateChanged += BackgroundMediaPlayer_CurrentStateChanged;
            //Playlist = await BackgroundPlaylist.LoadBackgroundPlaylist("playlist.xml");
            Playlist = new BackgroundPlaylist();
            Playlist.ListPathsource = await BackgroundPlaylist.LoadCurrentPlaylist(Constant.CurrentPlaylist);
            
            if (_foregroundState != eForegroundState.Suspended)
            {
                ValueSet message = new ValueSet();
                message.Add(Constant.BackgroundTaskStarted, "");
                BackgroundMediaPlayer.SendMessageToForeground(message);
            }  
            Playlist.TrackChanged += Playlist_TrackChanged;
            BackgroundMediaPlayer.MessageReceivedFromForeground += BackgroundMediaPlayer_MessageReceivedFromForeground;
            BackgroundMediaPlayer.Current.MediaEnded +=Current_MediaEnded;
            ApplicationSettingHelper.SaveSettingsValue(Constant.BackgroundTaskState, Constant.BackgroundTaskRunning);
            isbackgroundtaskrunning = true;
            _loopState = eLoopState.None;
        }
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            Loading.IsActive = true;
            AppServiceConnection connection = new AppServiceConnection();
            connection.PackageFamilyName = Package.Current.Id.FamilyName;
            connection.AppServiceName = "FeedParser";

            var status = await connection.OpenAsync();

            if (status == AppServiceConnectionStatus.Success)
            {
                ValueSet data = new ValueSet();
                data.Add("FeedUrl", "http://blog.qmatteoq.com/feed/");

                var response = await connection.SendMessageAsync(data);
                if (response.Status == AppServiceResponseStatus.Success)
                {
                    string items = response.Message["FeedItems"].ToString();
                    var result = JsonConvert.DeserializeObject<List<FeedItem>>(items);
                    News.ItemsSource = result;
                }
            }

            Loading.IsActive = false;
        }
Пример #24
0
        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 InitializeAppSvc()
        {
            string WebServerStatus = "PoolWebServer failed to start. AppServiceConnectionStatus was not successful.";

            // Initialize the AppServiceConnection
            appServiceConnection = new AppServiceConnection();
            appServiceConnection.PackageFamilyName = "PoolWebServer_hz258y3tkez3a";
            appServiceConnection.AppServiceName = "App2AppComService";

            // Send a initialize request 
            var res = await appServiceConnection.OpenAsync();
            if (res == AppServiceConnectionStatus.Success)
            {
                var message = new ValueSet();
                message.Add("Command", "Initialize");
                var response = await appServiceConnection.SendMessageAsync(message);
                if (response.Status != AppServiceResponseStatus.Success)
                {
                    WebServerStatus = "PoolWebServer failed to start.";
                    throw new Exception("Failed to send message");
                }
                appServiceConnection.RequestReceived += OnMessageReceived;
                WebServerStatus = "PoolWebServer started.";
            }

            await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                txtWebServerStatus.Text = WebServerStatus;
            });
        }
Пример #26
0
        public void RestorePlaylist()
        {
#if WINDOWS_PHONE_APP
            var msgDictionanary = new ValueSet();
            msgDictionanary.Add(BackgroundAudioConstants.RestorePlaylist, "");
            BackgroundMediaPlayer.SendMessageToBackground(msgDictionanary);
#endif
        }
Пример #27
0
        private async void ParseButton_Click(object sender, RoutedEventArgs e)
        {
            this.Items.Clear();

            this.appServiceConnection = new AppServiceConnection
            {
                AppServiceName = "com.shenchauhan.GroceryShop",
                PackageFamilyName = "292c6a2f-3028-412d-b530-23fbc868d2cb_8gdmnpqbw06hm"
            };

            var status = await this.appServiceConnection.OpenAsync();

            switch (status)
            {
                case AppServiceConnectionStatus.AppNotInstalled:
                    await LogError("The Grocery Shop application is not installed. Please install it and try again");
                    return;
                case AppServiceConnectionStatus.AppServiceUnavailable:
                    await LogError("The Grocery Shop application does not have the available feature");
                    return;
                case AppServiceConnectionStatus.Unknown:
                    await LogError("Uh-oh! erm.....");
                    return;
            }

            var items = this.NotesTextBox.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            var message = new ValueSet();

            for (int i = 0; i < items.Length; i++)
            {
                message.Add(i.ToString(), items[i]);
            }

            var response = await this.appServiceConnection.SendMessageAsync(message);

            switch (response.Status)
            {
                case AppServiceResponseStatus.ResourceLimitsExceeded:
                    await LogError("Yikes! The resource for this device exceeded the limits so the app service was shutdown");
                    return;
                case AppServiceResponseStatus.Failure:
                    await LogError("Oh dear, we failed to get a response");
                    return;
                case AppServiceResponseStatus.Unknown:
                    await LogError("uh-oh... Not sure why we didn't get a response");
                    return;
            }

            foreach (var item in response.Message)
            {
                this.Items.Add(new ShoppingItem
                {
                    Name = item.Key,
                    Price = item.Value.ToString()
                });
            }
        }
Пример #28
0
        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();
        }
Пример #29
0
        private async void CallAppService()
        {
            await EnsureConnectionToService();

            //Send data to the service 
            var message = new ValueSet();
            message.Add("Command", "CalcSum");
            message.Add("Value1", Int32.Parse(Value1.Text));
            message.Add("Value2", Int32.Parse(Value2.Text));

            //Send a message  
            AppServiceResponse response = await connection.SendMessageAsync(message);
            if (response.Status == AppServiceResponseStatus.Success)
            {
                int sum = (int)response.Message["Result"];
                ResultTextBox.Text = sum.ToString();
            }
        }
Пример #30
0
 private void TimerCallBack(object state)
 {
     if (_connection!=null)
     {
         var msg = new ValueSet();
         msg.Add("unsolicited", "you asked for it!");
         _connection.SendMessageAsync(msg).AsTask();
     }
 }
Пример #31
0
        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 "LoadContextMenu":
                var contextMenuResponse        = new ValueSet();
                var loadThreadWithMessageQueue = new Win32API.ThreadWithMessageQueue <ValueSet>(HandleMenuMessage);
                var cMenuLoad = await loadThreadWithMessageQueue.PostMessage <Win32API.ContextMenu>(args.Request.Message);

                contextMenuResponse.Add("Handle", handleTable.AddValue(loadThreadWithMessageQueue));
                contextMenuResponse.Add("ContextMenu", JsonConvert.SerializeObject(cMenuLoad));
                await args.Request.SendResponseAsync(contextMenuResponse);

                break;

            case "ExecAndCloseContextMenu":
                var menuKey = (string)args.Request.Message["Handle"];
                var execThreadWithMessageQueue = handleTable.GetValue <Win32API.ThreadWithMessageQueue <ValueSet> >(menuKey);
                if (execThreadWithMessageQueue != null)
                {
                    await execThreadWithMessageQueue.PostMessage(args.Request.Message);
                }
                // The following line is needed to cleanup resources when menu is closed.
                // Unfortunately if you uncomment it some menu items will randomly stop working.
                // Resource cleanup is currently done on app closing,
                // if we find a solution for the issue above, we should cleanup as soon as a menu is closed.
                //handleTable.RemoveValue(menuKey);
                break;

            case "InvokeVerb":
                var filePath = (string)args.Request.Message["FilePath"];
                var split    = filePath.Split('|').Where(x => !string.IsNullOrWhiteSpace(x));
                using (var cMenu = Win32API.ContextMenu.GetContextMenuForFiles(split.ToArray(), Shell32.CMF.CMF_DEFAULTONLY))
                {
                    cMenu?.InvokeVerb((string)args.Request.Message["Verb"]);
                }
                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;

            case "FileOperation":
                await parseFileOperation(args);

                break;

            case "GetIconOverlay":
                var fileIconPath = (string)args.Request.Message["filePath"];
                var iconOverlay  = Win32API.GetFileOverlayIcon(fileIconPath);
                await args.Request.SendResponseAsync(new ValueSet()
                {
                    { "IconOverlay", iconOverlay.icon },
                    { "HasCustomIcon", iconOverlay.isCustom }
                });

                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;
            }
        }
Пример #32
0
        public async override void GetSpecialProperties()
        {
            ViewModel.IsHidden = NativeFileOperationsHelper.HasFileAttribute(
                Item.ItemPath, System.IO.FileAttributes.Hidden);

            var fileIconData = await FileThumbnailHelper.LoadIconFromPathAsync(Item.ItemPath, 80, Windows.Storage.FileProperties.ThumbnailMode.SingleItem);

            if (fileIconData != null)
            {
                ViewModel.IconData        = fileIconData;
                ViewModel.LoadFolderGlyph = false;
                ViewModel.LoadFileIcon    = true;
            }

            if (Item.IsShortcutItem)
            {
                ViewModel.ItemSizeVisibility    = true;
                ViewModel.ItemSize              = Item.FileSizeBytes.ToLongSizeString();
                ViewModel.ItemCreatedTimestamp  = Item.ItemDateCreated;
                ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
                if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
                {
                    // Can't show any other property
                    return;
                }
            }

            string            folderPath = (Item as ShortcutItem)?.TargetPath ?? Item.ItemPath;
            BaseStorageFolder storageFolder;

            try
            {
                storageFolder = await AppInstance.FilesystemViewModel.GetFolderFromPathAsync(folderPath);
            }
            catch (Exception ex)
            {
                App.Logger.Warn(ex, ex.Message);
                // Could not access folder, can't show any other property
                return;
            }

            if (storageFolder != null)
            {
                ViewModel.ItemCreatedTimestamp = dateTimeFormatter.ToShortLabel(storageFolder.DateCreated);
                if (storageFolder.Properties != null)
                {
                    GetOtherProperties(storageFolder.Properties);
                }
                GetFolderSize(storageFolder.Path, TokenSource.Token);
            }
            else if (Item.ItemPath.Equals(CommonPaths.RecycleBinPath, StringComparison.OrdinalIgnoreCase))
            {
                // GetFolderFromPathAsync cannot access recyclebin folder
                var connection = await AppServiceConnectionHelper.Instance;
                if (connection != null)
                {
                    var value = new ValueSet();
                    value.Add("Arguments", "RecycleBin");
                    value.Add("action", "Query");
                    // Send request to fulltrust process to get recyclebin properties
                    var(status, response) = await connection.SendMessageForResponseAsync(value);

                    if (status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
                    {
                        if (response.TryGetValue("BinSize", out var binSize))
                        {
                            ViewModel.ItemSizeBytes      = (long)binSize;
                            ViewModel.ItemSize           = ByteSize.FromBytes((long)binSize).ToString();
                            ViewModel.ItemSizeVisibility = true;
                        }
                        else
                        {
                            ViewModel.ItemSizeVisibility = false;
                        }
                        if (response.TryGetValue("NumItems", out var numItems))
                        {
                            ViewModel.FilesCount = (int)(long)numItems;
                            SetItemsCountString();
                            ViewModel.FilesAndFoldersCountVisibility = true;
                        }
                        else
                        {
                            ViewModel.FilesAndFoldersCountVisibility = false;
                        }
                        ViewModel.ItemCreatedTimestampVisibiity   = false;
                        ViewModel.ItemAccessedTimestampVisibility = false;
                        ViewModel.ItemModifiedTimestampVisibility = false;
                        ViewModel.LastSeparatorVisibility         = false;
                    }
                }
            }
            else
            {
                GetFolderSize(folderPath, TokenSource.Token);
            }
        }
Пример #33
0
        public async Task ParseArgumentsAsync(PipeStream connection, Dictionary <string, object> message, string arguments)
        {
            switch (arguments)
            {
            case "LoadContextMenu":
                var contextMenuResponse        = new ValueSet();
                var loadThreadWithMessageQueue = new ThreadWithMessageQueue <Dictionary <string, object> >(HandleMenuMessage);
                var cMenuLoad = await loadThreadWithMessageQueue.PostMessageAsync <ContextMenu>(message);

                contextMenuResponse.Add("Handle", handleTable.AddValue(loadThreadWithMessageQueue));
                contextMenuResponse.Add("ContextMenu", JsonConvert.SerializeObject(cMenuLoad));
                await Win32API.SendMessageAsync(connection, contextMenuResponse, message.Get("RequestID", (string)null));

                break;

            case "ExecAndCloseContextMenu":
                var menuKey = (string)message["Handle"];
                var execThreadWithMessageQueue = handleTable.GetValue <ThreadWithMessageQueue <Dictionary <string, object> > >(menuKey);
                if (execThreadWithMessageQueue != null)
                {
                    await execThreadWithMessageQueue.PostMessage(message);
                }
                // The following line is needed to cleanup resources when menu is closed.
                // Unfortunately if you uncomment it some menu items will randomly stop working.
                // Resource cleanup is currently done on app closing,
                // if we find a solution for the issue above, we should cleanup as soon as a menu is closed.
                //handleTable.RemoveValue(menuKey);
                break;

            case "InvokeVerb":
                var filePath = (string)message["FilePath"];
                var split    = filePath.Split('|').Where(x => !string.IsNullOrWhiteSpace(x));
                var verb     = (string)message["Verb"];
                using (var cMenu = ContextMenu.GetContextMenuForFiles(split.ToArray(), Shell32.CMF.CMF_DEFAULTONLY))
                {
                    var result = cMenu?.InvokeVerb(verb);
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                    {
                        { "Success", result }
                    }, message.Get("RequestID", (string)null));
                }
                break;

            case "GetNewContextMenuEntries":
                var entries = await Extensions.IgnoreExceptions(() => ShellNewMenuHelper.GetNewContextMenuEntries(), Program.Logger);

                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "Entries", JsonConvert.SerializeObject(entries) }
                }, message.Get("RequestID", (string)null));

                break;

            case "GetNewContextMenuEntryForType":
                var fileExtension = (string)message["extension"];
                var entry         = await Extensions.IgnoreExceptions(() => ShellNewMenuHelper.GetNewContextMenuEntryForType(fileExtension), Program.Logger);

                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "Entry", JsonConvert.SerializeObject(entry) }
                }, message.Get("RequestID", (string)null));

                break;
            }
        }
Пример #34
0
        private async void ParseButton_Click(object sender, RoutedEventArgs e)
        {
            this.Items.Clear();

            this.appServiceConnection = new AppServiceConnection
            {
                AppServiceName    = "com.shenchauhan.GroceryShop",
                PackageFamilyName = "292c6a2f-3028-412d-b530-23fbc868d2cb_8gdmnpqbw06hm"
            };

            var status = await this.appServiceConnection.OpenAsync();

            switch (status)
            {
            case AppServiceConnectionStatus.AppNotInstalled:
                await LogError("The Grocery Shop application is not installed. Please install it and try again");

                return;

            case AppServiceConnectionStatus.AppServiceUnavailable:
                await LogError("The Grocery Shop application does not have the available feature");

                return;

            case AppServiceConnectionStatus.Unknown:
                await LogError("Uh-oh! erm.....");

                return;
            }

            var items = this.NotesTextBox.Text.Split(new string[] { "\r" }, StringSplitOptions.RemoveEmptyEntries);

            var message = new ValueSet();

            for (int i = 0; i < items.Length; i++)
            {
                message.Add(i.ToString(), items[i]);
            }

            var response = await this.appServiceConnection.SendMessageAsync(message);

            switch (response.Status)
            {
            case AppServiceResponseStatus.ResourceLimitsExceeded:
                await LogError("Yikes! The resource for this device exceeded the limits so the app service was shutdown");

                return;

            case AppServiceResponseStatus.Failure:
                await LogError("Oh dear, we failed to get a response");

                return;

            case AppServiceResponseStatus.Unknown:
                await LogError("uh-oh... Not sure why we didn't get a response");

                return;
            }

            foreach (var item in response.Message)
            {
                this.Items.Add(new ShoppingItem
                {
                    Name  = item.Key,
                    Price = item.Value.ToString()
                });
            }
        }
Пример #35
0
        private static async Task ParseArgumentsAsync(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 ParseRecycleBinActionAsync(args, binAction);

                break;

            case "DetectQuickLook":
                // Check QuickLook Availability
                var available = QuickLook.CheckQuickLookAvailability();
                await args.Request.SendResponseAsync(new ValueSet()
                {
                    { "IsAvailable", available }
                });

                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 "LoadContextMenu":
                var contextMenuResponse        = new ValueSet();
                var loadThreadWithMessageQueue = new Win32API.ThreadWithMessageQueue <ValueSet>(HandleMenuMessage);
                var cMenuLoad = await loadThreadWithMessageQueue.PostMessageAsync <Win32API.ContextMenu>(args.Request.Message);

                contextMenuResponse.Add("Handle", handleTable.AddValue(loadThreadWithMessageQueue));
                contextMenuResponse.Add("ContextMenu", JsonConvert.SerializeObject(cMenuLoad));
                await args.Request.SendResponseAsync(contextMenuResponse);

                break;

            case "ExecAndCloseContextMenu":
                var menuKey = (string)args.Request.Message["Handle"];
                var execThreadWithMessageQueue = handleTable.GetValue <Win32API.ThreadWithMessageQueue <ValueSet> >(menuKey);
                if (execThreadWithMessageQueue != null)
                {
                    await execThreadWithMessageQueue.PostMessage(args.Request.Message);
                }
                // The following line is needed to cleanup resources when menu is closed.
                // Unfortunately if you uncomment it some menu items will randomly stop working.
                // Resource cleanup is currently done on app closing,
                // if we find a solution for the issue above, we should cleanup as soon as a menu is closed.
                //handleTable.RemoveValue(menuKey);
                break;

            case "InvokeVerb":
                var filePath = (string)args.Request.Message["FilePath"];
                var split    = filePath.Split('|').Where(x => !string.IsNullOrWhiteSpace(x));
                using (var cMenu = Win32API.ContextMenu.GetContextMenuForFiles(split.ToArray(), Shell32.CMF.CMF_DEFAULTONLY))
                {
                    cMenu?.InvokeVerb((string)args.Request.Message["Verb"]);
                }
                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;

            case "SetVolumeLabel":
                var driveName = (string)args.Request.Message["drivename"];
                var newLabel  = (string)args.Request.Message["newlabel"];
                Win32API.SetVolumeLabel(driveName, newLabel);
                break;

            case "FileOperation":
                await ParseFileOperationAsync(args);

                break;

            case "GetIconOverlay":
                var fileIconPath  = (string)args.Request.Message["filePath"];
                var thumbnailSize = (int)args.Request.Message["thumbnailSize"];
                var iconOverlay   = Win32API.GetFileIconAndOverlay(fileIconPath, thumbnailSize);
                await args.Request.SendResponseAsync(new ValueSet()
                {
                    { "Icon", iconOverlay.icon },
                    { "Overlay", iconOverlay.overlay },
                    { "HasCustomIcon", iconOverlay.isCustom }
                });

                break;

            case "GetOneDriveAccounts":
                try
                {
                    var oneDriveAccountsKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\OneDrive\Accounts", false);

                    if (oneDriveAccountsKey == null)
                    {
                        await args.Request.SendResponseAsync(new ValueSet());

                        return;
                    }

                    var oneDriveAccounts = new ValueSet();
                    foreach (var account in oneDriveAccountsKey.GetSubKeyNames())
                    {
                        var accountKeyName = @$ "{oneDriveAccountsKey.Name}\{account}";
                        var displayName    = (string)Registry.GetValue(accountKeyName, "DisplayName", null);
                        var userFolder     = (string)Registry.GetValue(accountKeyName, "UserFolder", null);
                        var accountName    = string.IsNullOrWhiteSpace(displayName) ? "OneDrive" : $"OneDrive - {displayName}";
                        if (!string.IsNullOrWhiteSpace(userFolder) && !oneDriveAccounts.ContainsKey(accountName))
                        {
                            oneDriveAccounts.Add(accountName, userFolder);
                        }
                    }
                    await args.Request.SendResponseAsync(oneDriveAccounts);
                }
Пример #36
0
        private async Task WriteResponseAsync(string request, IOutputStream os)
        {
            // See if the request is for blinky.html, if yes get the new state
            string state     = "Unspecified";
            string axisState = "Unspecified";
            string axisdn    = "test.html?axis=down";

            char[] arr;
            string str          = "";
            string axisValue    = "";
            bool   stateChanged = false;

            // ListAvailablePorts();

            string html = offHtmlString; // default off

            if (request.Contains("blinky.html?state=on"))
            {
                state        = "On";
                stateChanged = true;
                html         = onHtmlString;
            }
            else if (request.Contains("blinky.html?state=off"))
            {
                state        = "Off";
                stateChanged = true;
                html         = offHtmlString;
            }
            else if (request.Contains("blinky.html?state=start"))
            {
                state        = "Start";
                stateChanged = true;
                html         = startHtmlString;
            }
            else if (request.Contains("blinky.html?state=test_on"))
            {
                state        = "Test_ON";
                stateChanged = true;
                html         = offHtmlString;
            }
            else if (request.Contains("blinky.html?state=test_off"))
            {
                state        = "Test_OFF";
                stateChanged = true;
                html         = offHtmlString;
            }
            else if (request.Contains("test.html?axis="))
            {
                axisState    = "On";
                stateChanged = true;

                string up = "test.html?axis=up";

                string sub = request.Substring(request.Length - 4, 4);
                if (request.Contains("down") == true)
                {
                    axisValue = "-";
                    //string str = request.Replace("test.html?axis=down", "");
                    axisValue += sub;
                }
                else
                {
                    axisValue = sub;
                }
            }
            else if (request.Contains("slice.html"))
            {
                //don't send any commands to backend just show current slice number
                html         = "<html><head><meta http-equiv=\"refresh\" content=\"5\" /></head><body></body>Current Slice :" + SliceName + "/" + TotalSliceName + "</html>";
                stateChanged = false;
            }


            if (stateChanged)
            {
                var updateMessage = new ValueSet();
                updateMessage.Add("State", state);
                updateMessage.Add("AxisState", axisState);
                updateMessage.Add("AxisValue", axisValue);
                //avar responseStatus = await appServiceConnection.SendMessageAsync(updateMessage);
                appServiceConnection.SendMessageAsync(updateMessage);
            }

            //string html = state == "On" ? onHtmlString : offHtmlString;
            // Show the html
            using (Stream resp = os.AsStreamForWrite())
            {
                // Look in the Data subdirectory of the app package
                byte[]       bodyArray = Encoding.UTF8.GetBytes(html);
                MemoryStream stream    = new MemoryStream(bodyArray);
                string       header    = String.Format("HTTP/1.1 200 OK\r\n" +
                                                       "Content-Length: {0}\r\n" +
                                                       "Connection: close\r\n\r\n",
                                                       stream.Length);
                byte[] headerArray = Encoding.UTF8.GetBytes(header);
                await resp.WriteAsync(headerArray, 0, headerArray.Length);

                await stream.CopyToAsync(resp);

                await resp.FlushAsync();
            }
        }
Пример #37
0
        async private void callAppService_Click(object sender, RoutedEventArgs e)
        {
            long number = 0;

            if (long.TryParse(input.Text, out number))
            {
                try
                {
                    callAppService.IsEnabled = false;

                    if (appServiceConnection == null)
                    {
                        appServiceConnection = new AppServiceConnection();
                        appServiceConnection.PackageFamilyName = APPSERVICE_PACKAGE_FAMILY_NAME;
                        appServiceConnection.AppServiceName    = "SomeArbitraryName";
                        AppServiceConnectionStatus result = await appServiceConnection.OpenAsync();

                        if (result != AppServiceConnectionStatus.Success)
                        {
                            appServiceConnection.Dispose();
                            appServiceConnection = null;
                            status.Log(LocalizableStrings.APPSERVICE_CREATE_FAIL);
                            closeAppService.IsEnabled = false;
                            return;
                        }
                        else
                        {
                            status.Log(LocalizableStrings.APPSERVICE_CREATE_SUCCESS);
                            closeAppService.IsEnabled = true;
                        }
                    }

                    ValueSet message     = new ValueSet();
                    string   requestText = input.Text;
                    message.Add("SQR", requestText);
                    AppServiceResponse response = await appServiceConnection.SendMessageAsync(message);

                    if (response.Status != AppServiceResponseStatus.Success)
                    {
                        status.Log(LocalizableStrings.APPSERVICE_SEND_FAIL);
                    }
                    else
                    {
                        string responseText = response.Message["Response"] as string;
                        status.Log(string.Format(
                                       CultureInfo.CurrentCulture, LocalizableStrings.APPSERVICE_SEND_RESULT, requestText, responseText));
                        result.Text = responseText;
                    }
                }
                catch (Exception ex)
                {
                    status.Log(ex.Message);
                }
                finally
                {
                    callAppService.IsEnabled = true;
                }
            }
            else
            {
                status.Log(LocalizableStrings.APPSERVICE_INVALID_INPUT);
            }
        }
Пример #38
0
        public async void CheckPathInput(ItemViewModel instance, string CurrentInput)
        {
            if (CurrentInput != instance.WorkingDirectory || App.CurrentInstance.ContentFrame.CurrentSourcePageType == typeof(YourHome))
            {
                //(App.CurrentInstance.OperationsControl as RibbonArea).RibbonViewModel.HomeItems.isEnabled = false;
                //(App.CurrentInstance.OperationsControl as RibbonArea).RibbonViewModel.ShareItems.isEnabled = false;

                if (CurrentInput.Equals("Home", StringComparison.OrdinalIgnoreCase) || CurrentInput.Equals("New tab", StringComparison.OrdinalIgnoreCase))
                {
                    App.CurrentInstance.ViewModel.WorkingDirectory = "New tab";
                    App.CurrentInstance.ContentFrame.Navigate(typeof(YourHome), "New tab", new SuppressNavigationTransitionInfo());
                }
                else
                {
                    switch (CurrentInput.ToLower())
                    {
                    case "%temp%":
                        CurrentInput = App.AppSettings.TempPath;
                        break;

                    case "%appdata":
                        CurrentInput = App.AppSettings.AppDataPath;
                        break;

                    case "%homepath%":
                        CurrentInput = App.AppSettings.HomePath;
                        break;

                    case "%windir%":
                        CurrentInput = App.AppSettings.WinDirPath;
                        break;
                    }

                    try
                    {
                        await StorageFolder.GetFolderFromPathAsync(CurrentInput);

                        App.CurrentInstance.ContentFrame.Navigate(App.AppSettings.GetLayoutType(), CurrentInput); // navigate to folder
                    }
                    catch (Exception)                                                                             // Not a folder or inaccessible
                    {
                        try
                        {
                            await StorageFile.GetFileFromPathAsync(CurrentInput);

                            await Interaction.InvokeWin32Component(CurrentInput);
                        }
                        catch (Exception ex) // Not a file or not accessible
                        {
                            // Launch terminal application if possible
                            var localSettings = ApplicationData.Current.LocalSettings;

                            foreach (var item in App.AppSettings.Terminals)
                            {
                                if (item.Path.Equals(CurrentInput, StringComparison.OrdinalIgnoreCase) || item.Path.Equals(CurrentInput + ".exe", StringComparison.OrdinalIgnoreCase))
                                {
                                    if (App.Connection != null)
                                    {
                                        var value = new ValueSet();
                                        value.Add("Application", item.Path);
                                        value.Add("Arguments", String.Format(item.arguments, App.CurrentInstance.ViewModel.WorkingDirectory));
                                        await App.Connection.SendMessageAsync(value);
                                    }
                                    return;
                                }
                            }

                            var dialog = new ContentDialog()
                            {
                                Title           = "Invalid item",
                                Content         = "The item referenced is either invalid or inaccessible.\nMessage:\n\n" + ex.Message,
                                CloseButtonText = "OK"
                            };

                            await dialog.ShowAsync();
                        }
                    }
                }

                App.CurrentInstance.NavigationToolbar.PathControlDisplayText = App.CurrentInstance.ViewModel.WorkingDirectory;
            }
        }
        private async void GenerateRandomNumber_Click(object sender, RoutedEventArgs e)
        {
            //Parse user input
            int  minValueInput = 0;
            bool valueParsed   = int.TryParse(MinValue.Text, out minValueInput);

            if (!valueParsed)
            {
                rootPage.NotifyUser("The Minimum Value should be a valid integer", NotifyType.ErrorMessage);
                return;
            }

            int maxValueInput = 0;

            valueParsed = int.TryParse(MaxValue.Text, out maxValueInput);
            if (!valueParsed)
            {
                rootPage.NotifyUser("The Maximum Value should be a valid integer", NotifyType.ErrorMessage);
                return;
            }

            if (maxValueInput <= minValueInput)
            {
                rootPage.NotifyUser("Maximum Value must be larger than Minimum Value", NotifyType.ErrorMessage);
                return;
            }

            using (var connection = new AppServiceConnection())
            {
                //Set up a new app service connection
                connection.AppServiceName    = "com.microsoft.randomnumbergenerator";
                connection.PackageFamilyName = "Microsoft.SDKSamples.AppServicesProvider.CS_8wekyb3d8bbwe";
                AppServiceConnectionStatus status = await connection.OpenAsync();

                switch (status)
                {
                case AppServiceConnectionStatus.Success:
                    // The new connection opened successfully
                    rootPage.NotifyUser("Connection established", NotifyType.StatusMessage);
                    break;

                case AppServiceConnectionStatus.AppNotInstalled:
                    rootPage.NotifyUser("The app AppServicesProvider is not installed. Deploy AppServicesProvider to this device and try again.", NotifyType.ErrorMessage);
                    return;

                case AppServiceConnectionStatus.AppUnavailable:
                    rootPage.NotifyUser("The app AppServicesProvider is not available. This could be because it is currently being updated or was installed to a removable device that is no longer available.", NotifyType.ErrorMessage);
                    return;

                case AppServiceConnectionStatus.AppServiceUnavailable:
                    rootPage.NotifyUser($"The app AppServicesProvider is installed but it does not provide the app service {connection.AppServiceName}", NotifyType.ErrorMessage);
                    return;

                default:
                case AppServiceConnectionStatus.Unknown:
                    rootPage.NotifyUser("An unknown error occurred while we were trying to open an AppServiceConnection.", NotifyType.ErrorMessage);
                    return;
                }

                //Set up the inputs and send a message to the service
                var inputs = new ValueSet();
                inputs.Add("minvalue", minValueInput);
                inputs.Add("maxvalue", maxValueInput);
                AppServiceResponse response = await connection.SendMessageAsync(inputs);

                //If the service responded with success display the result and walk away
                if (response.Status == AppServiceResponseStatus.Success &&
                    response.Message.ContainsKey("result"))
                {
                    var resultText = response.Message["result"].ToString();
                    if (!string.IsNullOrEmpty(resultText))
                    {
                        Result.Text = resultText;
                        rootPage.NotifyUser("App service responded with a result", NotifyType.StatusMessage);
                    }
                    else
                    {
                        rootPage.NotifyUser("App service did not respond with a result", NotifyType.ErrorMessage);
                    }

                    return;
                }

                //Something went wrong while sending a message. Let display
                //a meaningful error message
                switch (response.Status)
                {
                case AppServiceResponseStatus.Failure:
                    rootPage.NotifyUser("The service failed to acknowledge the message we sent it. It may have been terminated or it's RequestReceived handler might not be handling incoming messages correctly.", NotifyType.ErrorMessage);
                    return;

                case AppServiceResponseStatus.ResourceLimitsExceeded:
                    rootPage.NotifyUser("The service exceeded the resources allocated to it and had to be terminated.", NotifyType.ErrorMessage);
                    return;

                default:
                case AppServiceResponseStatus.Unknown:
                    rootPage.NotifyUser("An unknown error occurred while we were trying to send a message to the service.", NotifyType.ErrorMessage);
                    return;
                }
            }
        }
Пример #40
0
        /// <summary>
        /// Populates the page with content passed during navigation.  Any saved state is also
        /// provided when recreating a page from a prior session.
        /// </summary>
        /// <param name="sender">
        /// The source of the event; typically <see cref="NavigationHelper"/>
        /// </param>
        /// <param name="e">Event data that provides both the navigation parameter passed to
        /// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested and
        /// a dictionary of state preserved by this page during an earlier
        /// session.  The state will be null the first time a page is visited.</param>
        private async void NavigationHelper_LoadState(object sender, LoadStateEventArgs e)
        {
            bool failed       = false;
            var  errorMessage = string.Empty;

            try
            {
                prYuanwen.IsActive   = true;
                prYuanwen.Visibility = Visibility.Visible;
                lvYuanwen.Visibility = Visibility.Collapsed;

                var setting = new AppSettingsViewModel();
                if (setting != null)
                {
                    switch (setting.AudioSetting)
                    {
                    case "美音":
                        AudioType = Mp3Type.American;
                        break;

                    case "英音":
                        AudioType = Mp3Type.English;
                        break;

                    default:
                        AudioType = Mp3Type.American;
                        break;
                    }
                }

                bookTextKey = (string)e.NavigationParameter;

                var message = new ValueSet();
                message.Add("bookTextKey", bookTextKey);
                BackgroundMediaPlayer.SendMessageToBackground(message);

                var bookTextInfo = await GetBookTextDataSource.GetBookTextAsync(null, bookTextKey);

                this.DefaultViewModel["BookText"] = bookTextInfo;
                bookTitle = bookTextInfo.Value.Name;
                var sampleDataGroup =
                    await GetYuanWenListDataSource.GetYuanWenAsync(bookTextKey : bookTextKey);

                this.DefaultViewModel[FirstGroupName] = sampleDataGroup;

                var mp3file = await DownloadAudioFile();

                string[] fileInfo = new[] { bookTitle, mp3file, bookTextKey, "!autoplay" };
                message = new ValueSet
                {
                    {
                        "SetSource",
                        fileInfo
                    }
                };
                BackgroundMediaPlayer.SendMessageToBackground(message);
            }
            catch (Exception ex)
            {
                errorMessage = Helper.HandlerExceptionMessage(ex);
                failed       = true;
            }
            finally
            {
                prYuanwen.IsActive   = false;
                prYuanwen.Visibility = Visibility.Collapsed;
                lvYuanwen.Visibility = Visibility.Visible;
            }
            if (failed)
            {
                MessageDialog md2 = new MessageDialog(errorMessage, Constants.NETWORK_CONNECTION);
                await md2.ShowAsync();
            }
        }
Пример #41
0
        private async Task HandleShellRecentItemsMessage(Dictionary <string, object> message)
        {
            var action   = (string)message["action"];
            var response = new ValueSet();

            switch (action)
            {
            // enumerate `\Windows\Recent` for recent folders
            // note: files are enumerated using (Win32MessageHandler: "ShellFolder") in RecentItemsManager
            case "EnumerateFolders":
                var enumerateFoldersResponse = await Win32API.StartSTATask(() =>
                {
                    try
                    {
                        var shellLinkItems = new List <ShellLinkItem>();
                        var excludeMask    = FileAttributes.Hidden;
                        var linkFilePaths  = Directory.EnumerateFiles(RecentItemsPath).Where(f => (new FileInfo(f).Attributes & excludeMask) == 0);

                        foreach (var linkFilePath in linkFilePaths)
                        {
                            using var link = new ShellLink(linkFilePath, LinkResolution.NoUIWithMsgPump, null, TimeSpan.FromMilliseconds(100));

                            try
                            {
                                if (!string.IsNullOrEmpty(link.TargetPath) && link.Target.IsFolder)
                                {
                                    var shellLinkItem = ShellFolderExtensions.GetShellLinkItem(link);
                                    shellLinkItems.Add(shellLinkItem);
                                }
                            }
                            catch (FileNotFoundException)
                            {
                                // occurs when shortcut or shortcut target is deleted and accessed (link.Target)
                                // consequently, we shouldn't include the item as a recent item
                            }
                        }

                        response.Add("EnumerateFolders", JsonConvert.SerializeObject(shellLinkItems));
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Warn(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, enumerateFoldersResponse, message.Get("RequestID", (string)null));

                break;

            case "Add":
                var addResponse = await Win32API.StartSTATask(() =>
                {
                    try
                    {
                        var path = (string)message["Path"];
                        Shell32.SHAddToRecentDocs(Shell32.SHARD.SHARD_PATHW, path);
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Warn(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, addResponse, message.Get("RequestID", (string)null));

                break;

            case "Clear":
                var clearResponse = await Win32API.StartSTATask(() =>
                {
                    try
                    {
                        Shell32.SHAddToRecentDocs(Shell32.SHARD.SHARD_PIDL, (string)null);
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Warn(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, clearResponse, message.Get("RequestID", (string)null));

                break;

            // invoke 'remove' verb on the file to remove it from Quick Access
            // note: for folders, we need to use the verb 'unpinfromhome' or 'removefromhome'
            case "UnpinFile":
                var unpinFileResponse = await Win32API.StartSTATask(() =>
                {
                    try
                    {
                        var path    = (string)message["Path"];
                        var command = $"-command \"((New-Object -ComObject Shell.Application).Namespace('shell:{QuickAccessGuid}\').Items() " +
                                      $"| Where-Object {{ $_.Path -eq '{path}' }}).InvokeVerb('remove')\"";
                        bool success = Win32API.RunPowershellCommand(command, false);

                        response.Add("UnpinFile", path);
                        response.Add("Success", success);
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Warn(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, unpinFileResponse, message.Get("RequestID", (string)null));

                break;
            }
        }
Пример #42
0
        private static void GetReturnData(ValueSet message, ref ValueSet returnData)
        {
            string command = message["Command"] as string;

            switch (command.ToUpper())
            {
            case "INIT":
            {
                Hashtable result = CommonInit();
                string    status = "OK";
                if (!(bool)result[TypeZigBee])
                {
                    status = "\nFail to init ZigBee";
                }
                returnData.Add("Status", status);
            }
            break;

            case "GETPHRASELIST":
            {
                List <string> result = null;
                try
                {
                    using (var db = new IOTOI.Model.Db.Context())
                    {
                        result = (from ep in db.ZigBeeEndPoint
                                  where ep.CustomName != null
                                  select ep.CustomName)
                                 .ToList();
                    }
                }
                catch (Exception e)
                {
                    loggingServices.Write(Log, e.Message, LogLevel.Error, e);
                }
                returnData.Add("Result", JsonConvert.SerializeObject(result));
                returnData.Add("Status", "OK");
            }
            break;

            case "GETDEVICE":
            {
                returnData.Add("Result", JsonConvert.SerializeObject(ZigBeeService.GetEndPoint(message["Target"] as string)));
                returnData.Add("Status", "OK");
            }
            break;

            case "GETSTATUS":
            {
                returnData.Add("Result", ZigBeeService.GetEndPointStatus(message["Target"] as string));
                returnData.Add("Status", "OK");
            }
            break;

            case "SETNESTTOKEN":
            {
                strNestToken = message["NESTTOKEN"].ToString();

                Nest.NestCommandHandler.ThermostatAPI.ApplyAccessToken(strNestToken);

                returnData.Add("Status", "OK");
            }
            break;

            case "GETNESTSTATUS":
            {
                //TODO : NEST GET STATUS
                //Result CASE 1(temperature : 60)
                //Result CASE 2(fan : true or false)

                #region
                if (message["Target"].ToString() == "temperature")
                {
                    string r = Nest.NestCommandHandler.CurrentTemperature();
                    if (r.Contains("Fail:"))
                    {
                        returnData.Add("Status", r);
                    }
                    else
                    {
                        returnData.Add("Result", r);
                        returnData.Add("Status", "OK");
                    }
                }
                else
                if (message["Target"].ToString() == "fan")
                {
                    string r = Nest.NestCommandHandler.CurrentFanStatus();
                    if (r.Contains("Fail:"))
                    {
                        returnData.Add("Status", r);
                    }
                    else
                    {
                        returnData.Add("Result", r);            // FanRunning , FanStopped
                        returnData.Add("Status", "OK");
                    }
                }
                #endregion
            }
            break;

            default:
            {
                returnData.Add("Status", "Fail: unknown command");
                break;
            }
            }
        }
Пример #43
0
        public async override void GetSpecialProperties()
        {
            ViewModel.IsHidden = NativeFileOperationsHelper.HasFileAttribute(
                Item.ItemPath, System.IO.FileAttributes.Hidden);

            var fileIconInfo = await AppInstance.FilesystemViewModel.LoadIconOverlayAsync(Item.ItemPath, 80);

            if (fileIconInfo.Icon != null && fileIconInfo.IsCustom)
            {
                ViewModel.FileIconSource = fileIconInfo.Icon;
            }

            if (Item.IsShortcutItem)
            {
                ViewModel.ItemSizeVisibility = Visibility.Visible;
                ViewModel.ItemSize           = ByteSize.FromBytes(Item.FileSizeBytes).ToBinaryString().ConvertSizeAbbreviation()
                                               + " (" + ByteSize.FromBytes(Item.FileSizeBytes).Bytes.ToString("#,##0") + " " + "ItemSizeBytes".GetLocalized() + ")";
                ViewModel.ItemCreatedTimestamp  = Item.ItemDateCreated;
                ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
                if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
                {
                    // Can't show any other property
                    return;
                }
            }

            StorageFolder storageFolder;

            try
            {
                storageFolder = await AppInstance.FilesystemViewModel.GetFolderFromPathAsync((Item as ShortcutItem)?.TargetPath ?? Item.ItemPath);
            }
            catch (Exception ex)
            {
                NLog.LogManager.GetCurrentClassLogger().Error(ex, ex.Message);
                // Could not access folder, can't show any other property
                return;
            }

            if (storageFolder != null)
            {
                ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
                string returnformat = Enum.Parse <TimeStyle>(localSettings.Values[Constants.LocalSettings.DateTimeFormat].ToString()) == TimeStyle.Application ? "D" : "g";
                ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDateFromFormat(storageFolder.DateCreated, returnformat);
                GetOtherProperties(storageFolder.Properties);
                GetFolderSize(storageFolder, TokenSource.Token);
            }
            else if (Item.ItemPath.Equals(App.AppSettings.RecycleBinPath, StringComparison.OrdinalIgnoreCase))
            {
                // GetFolderFromPathAsync cannot access recyclebin folder
                if (AppInstance.FilesystemViewModel.Connection != null)
                {
                    var value = new ValueSet();
                    value.Add("Arguments", "RecycleBin");
                    value.Add("action", "Query");
                    // Send request to fulltrust process to get recyclebin properties
                    var response = await AppInstance.FilesystemViewModel.Connection.SendMessageAsync(value);

                    if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
                    {
                        if (response.Message.TryGetValue("BinSize", out var binSize))
                        {
                            ViewModel.ItemSizeBytes      = (long)binSize;
                            ViewModel.ItemSize           = ByteSize.FromBytes((long)binSize).ToString();
                            ViewModel.ItemSizeVisibility = Visibility.Visible;
                        }
                        else
                        {
                            ViewModel.ItemSizeVisibility = Visibility.Collapsed;
                        }
                        if (response.Message.TryGetValue("NumItems", out var numItems))
                        {
                            ViewModel.FilesCount = (int)(long)numItems;
                            SetItemsCountString();
                            ViewModel.FilesAndFoldersCountVisibility = Visibility.Visible;
                        }
                        else
                        {
                            ViewModel.FilesAndFoldersCountVisibility = Visibility.Collapsed;
                        }
                        ViewModel.ItemCreatedTimestampVisibiity   = Visibility.Collapsed;
                        ViewModel.ItemAccessedTimestampVisibility = Visibility.Collapsed;
                        ViewModel.ItemModifiedTimestampVisibility = Visibility.Collapsed;
                        ViewModel.ItemFileOwnerVisibility         = Visibility.Collapsed;
                        ViewModel.LastSeparatorVisibility         = Visibility.Collapsed;
                    }
                }
            }
        }
        public static async Task <ValueSet> FindElementProperty(ValueSet arguments)
        {
            ValueSet results = new ValueSet();

            if (Queue == null)
            {
                Log.Error("VisualTreeHelper - Missing UI DispatcherQueue");
                return(null);
            }

            await Queue.EnqueueAsync(() =>
            {
                // Dispatch?
                var content = Window.Current.Content as Frame;

                if (content == null)
                {
                    Log.Error("VisualTreeHelper.FindElementProperty - Window has no content.");
                    return;
                }

                if (arguments.TryGetValue("ElementName", out object value) && value is string name &&
                    arguments.TryGetValue("Property", out object value2) && value2 is string propertyName)
                {
                    Log.Comment("VisualTreeHelper.FindElementProperty('{0}', '{1}')", name, propertyName);

                    // 1. Find Element in Visual Tree
                    var element = content.FindDescendant(name);

                    try
                    {
                        Log.Comment("VisualTreeHelper.FindElementProperty - Found Element? {0}", element != null);

                        var typeinfo = element.GetType().GetTypeInfo();

                        Log.Comment("Element Type: {0}", typeinfo.FullName);

                        var prop = element.GetType().GetTypeInfo().GetProperty(propertyName);

                        if (prop == null)
                        {
                            Log.Error("VisualTreeHelper.FindElementProperty - Couldn't find Property named {0} on type {1}", propertyName, typeinfo.FullName);
                            return;
                        }

                        // 2. Get the property using reflection
                        var propValue = prop.GetValue(element);

                        // 3. Serialize and return the result
                        results.Add("Result", JsonSerializer.Serialize(propValue, SerializerOptions));
                    }
                    catch (Exception e)
                    {
                        Log.Error("Error {0}", e.Message);
                        Log.Error("StackTrace:\n{0}", e.StackTrace);
                    }
                }
            });

            if (results.Count > 0)
            {
                return(results);
            }

            return(null); // Failure
        }
Пример #45
0
        private async void InitAppSvc()
        {
            // Initialize the AppServiceConnection
            appServiceConnection = new AppServiceConnection();
            appServiceConnection.PackageFamilyName = "fe84f789-e7b7-4c2e-b960-955e3aab0ea0_vayj3az00mxpp";
            appServiceConnection.AppServiceName    = "App2AppComService";

            whAppServiceConnection = new AppServiceConnection();
            whAppServiceConnection.PackageFamilyName = "WHTaskConnectApp_vayj3az00mxpp";
            whAppServiceConnection.AppServiceName    = "org.laz.tcwebhook";

            // Send a initialize request
            var res = await appServiceConnection.OpenAsync();

            if (res == AppServiceConnectionStatus.Success)
            {
                var message = new ValueSet();
                message.Add("Command", "DashboardReady");
                var response = await appServiceConnection.SendMessageAsync(message);

                if (response.Status != AppServiceResponseStatus.Success)
                {
                    telemetry.TrackEvent("Laz.Org.AppService.Msg.Fail.App2AppComService");
                    throw new Exception("Failed to send message");
                }

                Debug.WriteLine("AppServiceConnection initialized");
                telemetry.TrackEvent("Laz.Org.AppService.Conn.Success.App2AppComService");
                appServiceConnection.RequestReceived += OnMessageReceived;
            }
            else
            {
                Debug.WriteLine("Failed to initialize AppServiceConnection");
                telemetry.TrackEvent("Laz.Org.AppService.Conn.Fail.App2AppComService");
            }


            //---
            var whRes = await whAppServiceConnection.OpenAsync();

            if (whRes == AppServiceConnectionStatus.Success)
            {
                var whMessage = new ValueSet();
                whMessage.Add("Command", "DashboardReady");

                var whResponse = await whAppServiceConnection.SendMessageAsync(whMessage);

                if (whResponse.Status != AppServiceResponseStatus.Success)
                {
                    telemetry.TrackEvent("Laz.Org.AppService.Msg.Fail.tcwebhook");
                    throw new Exception("Failed to send message to WH service");
                }

                whAppServiceConnection.RequestReceived += WhAppServiceConnection_RequestReceived;
                telemetry.TrackEvent("Laz.Org.AppService.Conn.Success.tcwebhook");
            }
            else
            {
                Debug.WriteLine("Failed to connect to WH app service connection");
                telemetry.TrackEvent("Laz.Org.AppServiceInitialize.Conn.Fail.tcwebhook");
            }
        }
Пример #46
0
 public void Serialize(ValueSet value)
 {
     value.Add(nameof(Songs), Songs);
 }
        // Method for activating Radio
        private void Button_Click_2(object sender, RoutedEventArgs e)
        {
            var loader = new Windows.ApplicationModel.Resources.ResourceLoader();

            networkStatus.Text       = loader.GetString("CS_Text2");
            networkStatus.Foreground = new SolidColorBrush(Colors.Yellow);
            InternetTest.Navigate(new Uri("http://curiosity.shoutca.st:8019/stream"));

            if (InternetAvailable == true)
            {
                if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable() == true)
                {
                    streamStatus.Text        = loader.GetString("CS_Text20");
                    streamStatus.Foreground  = new SolidColorBrush(Colors.Gray);
                    networkStatus.Text       = "...";
                    networkStatus.Foreground = new SolidColorBrush(Colors.Green);
                    try
                    {
                        streamStatus.Text = loader.GetString("CS_Text21");

                        if (MediaPlayerState.Playing != BackgroundMediaPlayer.Current.CurrentState)
                        {
                            BackgroundAudioTask.MyBackgroundAudioTask backgroundAccess = new BackgroundAudioTask.MyBackgroundAudioTask();
                            streamStatus.Text = loader.GetString("CS_Text22");
                            var message = new ValueSet();
                            streamStatus.Text = loader.GetString("CS_Text23");
                            ApplicationSettingsHelper.SaveSettingsValue(Constants.CurrentTrack, "192");
                            streamStatus.Text = loader.GetString("CS_Text24");
                            message.Add(Constants.StartPlayback, "0");
                            streamStatus.Text = loader.GetString("CS_Text25");
                            BackgroundMediaPlayer.SendMessageToBackground(message);
                        }

                        streamStatus.Text = "...";
                    }
                    catch (Exception)
                    {
                        networkStatus.Text       = loader.GetString("CS_Text26");
                        networkStatus.Foreground = new SolidColorBrush(Colors.Red);
                        if (MediaPlayerState.Playing == BackgroundMediaPlayer.Current.CurrentState)
                        {
                            streamStatus.Text = loader.GetString("CS_Text27");
                        }
                        else
                        {
                            try
                            {
                                BackgroundMediaPlayer.Current.Play();
                            }
                            catch (Exception) { }
                        }
                    }
                }
                else
                {
                    networkStatus.Text       = loader.GetString("CS_Text28");
                    networkStatus.Foreground = new SolidColorBrush(Colors.Yellow);
                    streamStatus.Text        = loader.GetString("CS_Text29");
                    streamStatus.Foreground  = new SolidColorBrush(Colors.Red);
                }
            }
            else // If Internet Is Not Available
            {
                networkStatus.Text       = loader.GetString("CS_Text30");
                networkStatus.Foreground = new SolidColorBrush(Colors.Red);
                streamStatus.Text        = loader.GetString("CS_Text31");
                streamStatus.Foreground  = new SolidColorBrush(Colors.Red);
            }
        }
Пример #48
0
        private void mediaElement_CurrentStateChanged(object sender, RoutedEventArgs e)
        {
            switch (mediaElement.CurrentState)
            {
            case MediaElementState.Closed:
                btn_Play.Visibility  = Visibility.Visible;
                btn_Pause.Visibility = Visibility.Collapsed;
                LoadDanmu            = false;
                break;

            case MediaElementState.Opening:
                btn_Play.Visibility  = Visibility.Visible;
                btn_Pause.Visibility = Visibility.Collapsed;
                progress.Visibility  = Visibility.Visible;
                LoadDanmu            = false;

                break;

            case MediaElementState.Buffering:
                btn_Play.Visibility  = Visibility.Collapsed;
                btn_Pause.Visibility = Visibility.Visible;
                progress.Visibility  = Visibility.Visible;
                LoadDanmu            = false;
                try{
                    ValueSet vs = new ValueSet();
                    vs.Add("Play", "Playing");
                    BackgroundMediaPlayer.SendMessageToBackground(vs);
                }
                catch { }
                break;

            case MediaElementState.Playing:
                btn_Play.Visibility  = Visibility.Collapsed;
                btn_Pause.Visibility = Visibility.Visible;
                progress.Visibility  = Visibility.Collapsed;

                LoadDanmu = true;
                try{
                    ValueSet vs = new ValueSet();
                    vs.Add("Play", "Playing");
                    BackgroundMediaPlayer.SendMessageToBackground(vs);
                }
                catch { }
                break;

            case MediaElementState.Paused:
                btn_Play.Visibility  = Visibility.Visible;
                btn_Pause.Visibility = Visibility.Collapsed;
                progress.Visibility  = Visibility.Collapsed;
                LoadDanmu            = false;
                try{
                    ValueSet vs = new ValueSet();
                    vs.Add("Play", "Paused");
                    BackgroundMediaPlayer.SendMessageToBackground(vs);
                }
                catch { }
                break;

            case MediaElementState.Stopped:
                btn_Play.Visibility  = Visibility.Visible;
                btn_Pause.Visibility = Visibility.Collapsed;
                progress.Visibility  = Visibility.Collapsed;
                LoadDanmu            = false;
                try{
                    ValueSet vs = new ValueSet();
                    vs.Add("Play", "Paused");
                    BackgroundMediaPlayer.SendMessageToBackground(vs);
                }
                catch { }
                break;

            default:
                break;
            }
        }
Пример #49
0
        public async override void GetSpecialProperties()
        {
            if (Item.IsShortcutItem)
            {
                ViewModel.ItemSizeVisibility = Visibility.Visible;
                ViewModel.ItemSize           = ByteSize.FromBytes(Item.FileSizeBytes).ToBinaryString().ConvertSizeAbbreviation()
                                               + " (" + ByteSize.FromBytes(Item.FileSizeBytes).Bytes.ToString("#,##0") + " " + "ItemSizeBytes".GetLocalized() + ")";
                ViewModel.ItemCreatedTimestamp  = Item.ItemDateCreated;
                ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
                if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
                {
                    // Can't show any other property
                    return;
                }
            }

            var parentDirectory = App.CurrentInstance.FilesystemViewModel.CurrentFolder;

            StorageFolder storageFolder = null;

            try
            {
                var isItemSelected = await CoreApplication.MainView.ExecuteOnUIThreadAsync(() => App.CurrentInstance?.ContentPage?.IsItemSelected ?? true);

                if (isItemSelected)
                {
                    storageFolder = await ItemViewModel.GetFolderFromPathAsync((Item as ShortcutItem)?.TargetPath ?? Item.ItemPath);
                }
                else if (!parentDirectory.ItemPath.StartsWith(App.AppSettings.RecycleBinPath))
                {
                    storageFolder = await ItemViewModel.GetFolderFromPathAsync(parentDirectory.ItemPath);
                }
            }
            catch (Exception ex)
            {
                NLog.LogManager.GetCurrentClassLogger().Error(ex, ex.Message);
                // Could not access folder, can't show any other property
                return;
            }

            if (storageFolder != null)
            {
                ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
                string returnformat = Enum.Parse <TimeStyle>(localSettings.Values[LocalSettings.DateTimeFormat].ToString()) == TimeStyle.Application ? "D" : "g";
                ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDateFromFormat(storageFolder.DateCreated, returnformat);
                LoadFolderIcon(storageFolder);
                GetOtherProperties(storageFolder.Properties);
                GetFolderSize(storageFolder, TokenSource.Token);
            }
            else if (parentDirectory.ItemPath.StartsWith(App.AppSettings.RecycleBinPath))
            {
                // GetFolderFromPathAsync cannot access recyclebin folder
                if (App.Connection != null)
                {
                    var value = new ValueSet();
                    value.Add("Arguments", "RecycleBin");
                    value.Add("action", "Query");
                    // Send request to fulltrust process to get recyclebin properties
                    var response = await App.Connection.SendMessageAsync(value);

                    if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
                    {
                        if (response.Message.TryGetValue("BinSize", out var binSize))
                        {
                            ViewModel.ItemSizeBytes      = (long)binSize;
                            ViewModel.ItemSize           = ByteSize.FromBytes((long)binSize).ToString();
                            ViewModel.ItemSizeVisibility = Visibility.Visible;
                        }
                        else
                        {
                            ViewModel.ItemSizeVisibility = Visibility.Collapsed;
                        }
                        if (response.Message.TryGetValue("NumItems", out var numItems))
                        {
                            ViewModel.FilesCount = (int)(long)numItems;
                            SetItemsCountString();
                            ViewModel.FilesAndFoldersCountVisibility = Visibility.Visible;
                        }
                        else
                        {
                            ViewModel.FilesAndFoldersCountVisibility = Visibility.Collapsed;
                        }
                        ViewModel.ItemCreatedTimestampVisibiity   = Visibility.Collapsed;
                        ViewModel.ItemAccessedTimestampVisibility = Visibility.Collapsed;
                        ViewModel.ItemModifiedTimestampVisibility = Visibility.Collapsed;
                        ViewModel.ItemFileOwnerVisibility         = Visibility.Collapsed;
                        ViewModel.LastSeparatorVisibility         = Visibility.Collapsed;
                    }
                }
            }
        }
Пример #50
0
 public void Serialize(ValueSet value)
 {
     value.Add(nameof(Timestamp), Timestamp);
 }
Пример #51
0
        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();
            var    result          = new ValueSet();
            string response        = AppServiceTaskConstant.RESULT_FIELD_ERROR_VALUE;

            try
            {
                if ((args.Request != null) && (args.Request.Message != null))
                {
                    var inputs = args.Request.Message;
                    if (inputs.ContainsKey(AppServiceTaskConstant.COMMAND_FIELD))
                    {
                        string s = (string)inputs[AppServiceTaskConstant.COMMAND_FIELD];
                        if (string.Equals(s, AppServiceTaskConstant.COMMAND_FIELD_DATA_VALUE))
                        {
                            if ((inputs.ContainsKey(AppServiceTaskConstant.DATA_FIELD)) &&
                                (inputs.ContainsKey(AppServiceTaskConstant.SOURCE_FIELD)))
                            {
                                string data   = (string)inputs[AppServiceTaskConstant.DATA_FIELD];
                                string source = (string)inputs[AppServiceTaskConstant.SOURCE_FIELD];
                                if ((string.Equals(source, AppServiceTaskConstant.SOURCE_FIELD_LOCAL_VALUE)) &&
                                    (remoteConnectionList != null) &&
                                    (remoteConnectionList.Count > 0))
                                {
                                    bool res = await SendMessage(true, inputs);

                                    if (res == true)
                                    {
                                        System.Diagnostics.Debug.WriteLine("AppService Task data sent");
                                        response = AppServiceTaskConstant.RESULT_FIELD_OK_VALUE;
                                    }
                                    else
                                    {
                                        response = AppServiceTaskConstant.RESULT_FIELD_ERROR_VALUE;
                                    }
                                }
                                else if ((string.Equals(source, AppServiceTaskConstant.SOURCE_FIELD_REMOTE_VALUE)) &&
                                         (localConnectionList != null) &&
                                         (localConnectionList.Count > 0))
                                {
                                    bool res = await SendMessage(false, inputs);

                                    if (res == true)
                                    {
                                        System.Diagnostics.Debug.WriteLine("AppService Task data sent");
                                        response = AppServiceTaskConstant.RESULT_FIELD_OK_VALUE;
                                    }
                                    else
                                    {
                                        response = AppServiceTaskConstant.RESULT_FIELD_ERROR_VALUE;
                                    }
                                }
                                else
                                {
                                    response = AppServiceTaskConstant.RESULT_FIELD_ERROR_VALUE;
                                }
                            }
                        }
                        else if (string.Equals(s, AppServiceTaskConstant.COMMAND_FIELD_INIT_VALUE))
                        {
                            // Background task started
                            if ((inputs.ContainsKey(AppServiceTaskConstant.SOURCE_FIELD)))
                            {
                                string source = (string)inputs[AppServiceTaskConstant.SOURCE_FIELD];
                                if ((string.Equals(source, AppServiceTaskConstant.SOURCE_FIELD_LOCAL_VALUE)) &&
                                    (localConnectionList != null))
                                {
                                    SetConnected(false, sender, true);
                                    response = AppServiceTaskConstant.RESULT_FIELD_OK_VALUE;
                                    System.Diagnostics.Debug.WriteLine("AppService Connection established");
                                }
                                else if ((string.Equals(source, AppServiceTaskConstant.SOURCE_FIELD_REMOTE_VALUE)) &&
                                         (remoteConnectionList != null))
                                {
                                    SetConnected(true, sender, true);
                                    response = AppServiceTaskConstant.RESULT_FIELD_OK_VALUE;
                                    System.Diagnostics.Debug.WriteLine("AppService Connection established");
                                }
                                else
                                {
                                    response = AppServiceTaskConstant.RESULT_FIELD_ERROR_VALUE;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine("Exception while receiving message: " + e.Message);
            }
            finally
            {
                result.Add(AppServiceTaskConstant.RESULT_FIELD, response);
                await args.Request.SendResponseAsync(result);

                //Complete the message deferral so the platform knows we're done responding
                messageDeferral.Complete();
            }
        }
Пример #52
0
        public async Task ParseArgumentsAsync(PipeStream connection, Dictionary <string, object> message, string arguments)
        {
            switch (arguments)
            {
            case "Bitlocker":
                var bitlockerAction = (string)message["action"];
                if (bitlockerAction == "Unlock")
                {
                    var drive    = (string)message["drive"];
                    var password = (string)message["password"];
                    Win32API.UnlockBitlockerDrive(drive, password);
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                    {
                        { "Bitlocker", "Unlock" }
                    }, message.Get("RequestID", (string)null));
                }
                break;

            case "SetVolumeLabel":
                var driveName = (string)message["drivename"];
                var newLabel  = (string)message["newlabel"];
                Win32API.SetVolumeLabel(driveName, newLabel);
                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "SetVolumeLabel", driveName }
                }, message.Get("RequestID", (string)null));

                break;

            case "GetIconOverlay":
                var fileIconPath  = (string)message["filePath"];
                var thumbnailSize = (int)(long)message["thumbnailSize"];
                var isOverlayOnly = (bool)message["isOverlayOnly"];
                var iconOverlay   = await Win32API.StartSTATask(() => Win32API.GetFileIconAndOverlay(fileIconPath, thumbnailSize, true, isOverlayOnly));

                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "Icon", iconOverlay.icon },
                    { "Overlay", iconOverlay.overlay }
                }, message.Get("RequestID", (string)null));

                break;

            case "GetIconWithoutOverlay":
                var fileIconPath2  = (string)message["filePath"];
                var thumbnailSize2 = (int)(long)message["thumbnailSize"];
                var icon2          = await Win32API.StartSTATask(() => Win32API.GetFileIconAndOverlay(fileIconPath2, thumbnailSize2, false));

                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "Icon", icon2.icon },
                }, message.Get("RequestID", (string)null));

                break;

            case "ShellFolder":
                // Enumerate shell folder contents and send response to UWP
                var folderPath         = (string)message["folder"];
                var responseEnum       = new ValueSet();
                var folderContentsList = await Win32API.StartSTATask(() =>
                {
                    var flc = new List <ShellFileItem>();
                    try
                    {
                        using (var shellFolder = new ShellFolder(folderPath))
                        {
                            foreach (var folderItem in shellFolder)
                            {
                                try
                                {
                                    var shellFileItem = ShellFolderExtensions.GetShellFileItem(folderItem);
                                    flc.Add(shellFileItem);
                                }
                                catch (FileNotFoundException)
                                {
                                    // Happens if files are being deleted
                                }
                                finally
                                {
                                    folderItem.Dispose();
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                    return(flc);
                });

                responseEnum.Add("Enumerate", JsonConvert.SerializeObject(folderContentsList));
                await Win32API.SendMessageAsync(connection, responseEnum, message.Get("RequestID", (string)null));

                break;

            case "GetFolderIconsFromDLL":
                var iconInfos = Win32API.ExtractIconsFromDLL((string)message["iconFile"]);
                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "IconInfos", JsonConvert.SerializeObject(iconInfos) },
                }, message.Get("RequestID", (string)null));

                break;

            case "SetCustomFolderIcon":
                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "Success", Win32API.SetCustomDirectoryIcon((string)message["folder"], (string)message["iconFile"], (int)message.Get("iconIndex", 0L)) },
                }, message.Get("RequestID", (string)null));

                break;

            case "GetSelectedIconsFromDLL":
                var selectedIconInfos = Win32API.ExtractSelectedIconsFromDLL((string)message["iconFile"], JsonConvert.DeserializeObject <List <int> >((string)message["iconIndexes"]), Convert.ToInt32(message["requestedIconSize"]));
                await Win32API.SendMessageAsync(connection, new ValueSet()
                {
                    { "IconInfos", JsonConvert.SerializeObject(selectedIconInfos) },
                }, message.Get("RequestID", (string)null));

                break;

            case "SetAsDefaultExplorer":
            {
                var enable     = (bool)message["Value"];
                var destFolder = Path.Combine(ApplicationData.Current.LocalFolder.Path, "FilesOpenDialog");
                Directory.CreateDirectory(destFolder);
                foreach (var file in Directory.GetFiles(Path.Combine(Package.Current.InstalledLocation.Path, "Files.Launcher", "Assets", "FilesOpenDialog")))
                {
                    if (!Extensions.IgnoreExceptions(() => File.Copy(file, Path.Combine(destFolder, Path.GetFileName(file)), true), Program.Logger))
                    {
                        // Error copying files
                        DetectIsSetAsDefaultFileManager();
                        await Win32API.SendMessageAsync(connection, new ValueSet()
                            {
                                { "Success", false }
                            }, message.Get("RequestID", (string)null));

                        return;
                    }
                }

                try
                {
                    using var regProcess = Process.Start("regedit.exe", @$ "/s " "{Path.Combine(destFolder, enable ? " SetFilesAsDefault.reg " : " UnsetFilesAsDefault.reg ")}" "");
                    regProcess.WaitForExit();
                    DetectIsSetAsDefaultFileManager();
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                        {
                            { "Success", true }
                        }, message.Get("RequestID", (string)null));
                }
                catch
                {
                    // Canceled UAC
                    DetectIsSetAsDefaultFileManager();
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                        {
                            { "Success", false }
                        }, message.Get("RequestID", (string)null));
                }
            }
            break;

            case "SetAsOpenFileDialog":
            {
                var enable     = (bool)message["Value"];
                var destFolder = Path.Combine(ApplicationData.Current.LocalFolder.Path, "FilesOpenDialog");
                Directory.CreateDirectory(destFolder);
                foreach (var file in Directory.GetFiles(Path.Combine(Package.Current.InstalledLocation.Path, "Files.Launcher", "Assets", "FilesOpenDialog")))
                {
                    if (!Extensions.IgnoreExceptions(() => File.Copy(file, Path.Combine(destFolder, Path.GetFileName(file)), true), Program.Logger))
                    {
                        // Error copying files
                        DetectIsSetAsOpenFileDialog();
                        await Win32API.SendMessageAsync(connection, new ValueSet()
                            {
                                { "Success", false }
                            }, message.Get("RequestID", (string)null));

                        return;
                    }
                }

                try
                {
                    using var regProc32 = Process.Start("regsvr32.exe", @$ "/s /n {(!enable ? " / u " : " ")} /i:user " "{Path.Combine(destFolder, " CustomOpenDialog32.dll ")}" "");
                    regProc32.WaitForExit();
                    using var regProc64 = Process.Start("regsvr32.exe", @$ "/s /n {(!enable ? " / u " : " ")} /i:user " "{Path.Combine(destFolder, " CustomOpenDialog64.dll ")}" "");
                    regProc64.WaitForExit();

                    DetectIsSetAsOpenFileDialog();
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                        {
                            { "Success", true }
                        }, message.Get("RequestID", (string)null));
                }
                catch
                {
                    DetectIsSetAsOpenFileDialog();
                    await Win32API.SendMessageAsync(connection, new ValueSet()
                        {
                            { "Success", false }
                        }, message.Get("RequestID", (string)null));
                }
            }
            break;

            case "GetFileAssociation":
            {
                var filePath = (string)message["filepath"];
                await Win32API.SendMessageAsync(connection, new ValueSet()
                    {
                        { "FileAssociation", await Win32API.GetFileAssociationAsync(filePath, true) }
                    }, message.Get("RequestID", (string)null));
            }
            break;
            }
        }
Пример #53
0
        public async override void GetSpecialProperties()
        {
            if (Item.IsShortcutItem)
            {
                ViewModel.ItemSizeVisibility = Visibility.Visible;
                ViewModel.ItemSize           = ByteSize.FromBytes(Item.FileSizeBytes).ToBinaryString().ConvertSizeAbbreviation()
                                               + " (" + ByteSize.FromBytes(Item.FileSizeBytes).Bytes.ToString("#,##0") + " " + ResourceController.GetTranslation("ItemSizeBytes") + ")";
                ViewModel.ItemCreatedTimestamp  = Item.ItemDateCreated;
                ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
                // Can't show any other property
                return;
            }

            StorageFolder storageFolder;
            var           isItemSelected = await CoreApplication.MainView.ExecuteOnUIThreadAsync(() => App.CurrentInstance.ContentPage.IsItemSelected);

            if (isItemSelected)
            {
                storageFolder = await ItemViewModel.GetFolderFromPathAsync(Item.ItemPath);

                ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDate(storageFolder.DateCreated);
                GetOtherProperties(storageFolder.Properties);
                GetFolderSize(storageFolder, TokenSource.Token);
            }
            else
            {
                var parentDirectory = App.CurrentInstance.FilesystemViewModel.CurrentFolder;
                if (parentDirectory.ItemPath.StartsWith(App.AppSettings.RecycleBinPath))
                {
                    // GetFolderFromPathAsync cannot access recyclebin folder
                    if (App.Connection != null)
                    {
                        var value = new ValueSet();
                        value.Add("Arguments", "RecycleBin");
                        value.Add("action", "Query");
                        // Send request to fulltrust process to get recyclebin properties
                        var response = await App.Connection.SendMessageAsync(value);

                        if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
                        {
                            if (response.Message.TryGetValue("BinSize", out var binSize))
                            {
                                ViewModel.ItemSizeBytes      = (long)binSize;
                                ViewModel.ItemSize           = ByteSize.FromBytes((long)binSize).ToString();
                                ViewModel.ItemSizeVisibility = Visibility.Visible;
                            }
                            else
                            {
                                ViewModel.ItemSizeVisibility = Visibility.Collapsed;
                            }
                            if (response.Message.TryGetValue("NumItems", out var numItems))
                            {
                                ViewModel.FilesCount = (int)(long)numItems;
                                SetItemsCountString();
                                ViewModel.FilesAndFoldersCountVisibility = Visibility.Visible;
                            }
                            else
                            {
                                ViewModel.FilesAndFoldersCountVisibility = Visibility.Collapsed;
                            }
                            ViewModel.ItemCreatedTimestampVisibiity   = Visibility.Collapsed;
                            ViewModel.ItemAccessedTimestampVisibility = Visibility.Collapsed;
                            ViewModel.ItemModifiedTimestampVisibility = Visibility.Collapsed;
                            ViewModel.ItemFileOwnerVisibility         = Visibility.Collapsed;
                            ViewModel.LastSeparatorVisibility         = Visibility.Collapsed;
                        }
                    }
                }
                else
                {
                    storageFolder = await ItemViewModel.GetFolderFromPathAsync(parentDirectory.ItemPath);

                    ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDate(storageFolder.DateCreated);
                    GetOtherProperties(storageFolder.Properties);
                    GetFolderSize(storageFolder, TokenSource.Token);
                }
            }
        }
Пример #54
0
        private async void DataServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
        {
            Debug.WriteLine($"DataServiceRequestReceived");

            AppServiceResponse result;
            AppServiceResponseStatus resultStatus;
            var messageDeferral = args.GetDeferral();
            var request = args.Request;
            var m = request.Message;
            object command;
            try
            {
                m.TryGetValue("Command", out command);
                switch (command as string)
                {
                    case "Connect":
                        object role;
                        m.TryGetValue("Role", out role);
                        if (role as string == "DataStreamerConnect") // Client
                        { 
                            _dataConnection = sender;
                        }
                        var response = new ValueSet();
                        response.Add("Response", "OK");
                        await request.SendResponseAsync(response);
                        SendStatusAsync();
                        break;
                    case "Write":
                        object data;
                        if (m.TryGetValue("Data", out data))
                        {
                            Debug.WriteLine($"Write data:{data}");
                            if (_excelConnection != null)
                            {
                                result = await _excelConnection.SendMessageAsync(m);

                                if (result.Status != AppServiceResponseStatus.Success)
                                {
                                    Debug.WriteLine($"Failed to send data: {result.Status.ToString()}");
                                }
                                else
                                {
                                    Debug.WriteLine($"Sent: {data as string}");
                                }
                            }
                            else
                            {
                                Debug.WriteLine($"Failed to send data: no Excel Connection exists");
                            }
                        }
                        break;
                    case "Read":
                        var msg = new ValueSet();
                        AppServiceResponse res = null;
                        msg["Command"] = "Read";

                        if (_excelConnection != null)
                        {
                            res = _excelConnection.SendMessageAsync(msg).AsTask().Result; ;
                            if (res.Status == AppServiceResponseStatus.Success)
                            {
                                Debug.WriteLine($"Data recieved from Excel: {res.Message.Count}");
                                if (_dataConnection != null)
                                {
                                    //var clientRes = _dataConnection.SendMessageAsync(res.Message).AsTask().Result;
                                    var clientRes = await request.SendResponseAsync(res.Message);

                                    if (clientRes != AppServiceResponseStatus.Success)
                                    {
                                        Debug.WriteLine($"Failed to send read data to client: {clientRes.ToString()}");
                                    } else
                                    {
                                        Debug.WriteLine($"Data sent to client: {res.Message.Count}");
                                    }
                                }
                            }
                            else
                            {
                                Debug.WriteLine($"Failed to send data: {res.Status.ToString()}");
                            }
                        }
                        break;
                    case "Status":
                        var message = new ValueSet();
                        message.Add("Command", "Status");
                        message.Add("Data", String.Format("Client:{0},Excel:{1}", _dataConnection != null, _excelConnection != null));
                        resultStatus = request.SendResponseAsync(message).AsTask().Result;
                        if (resultStatus != AppServiceResponseStatus.Success)
                        {
                            Debug.WriteLine($"Failed to send data: {resultStatus}");
                        }
                        break;
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine($"Exception while sending the response : {e.Message}");
            }
            finally
            {
                // Complete the deferral so that the platform knows that we're done responding to the app service call.
                // Note for error handling: this must be called even if SendResponseAsync() throws an exception.
                messageDeferral.Complete();
            }
        }
Пример #55
0
        private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
        {
            var messageDeferral = args.GetDeferral();

            ValueSet message    = args.Request.Message;
            ValueSet returnData = new ValueSet();

            try
            {
                string command   = message["Command"] as string;
                string todoTitle = message["Title"] as string;

                if (command == "Add Todo" && todoTitle.Length > 0)
                {
                    ObservableCollection <TodoItem> todos = new ObservableCollection <TodoItem>();
                    bool settingsCreated = false;
                    int  lastID          = 0;
                    if (ApplicationData.Current.LocalSettings.Values.TryGetValue(Local_Settings_Todo, out object json))
                    {
                        JsonSerializerSettings settings = new JsonSerializerSettings();
                        settings.TypeNameHandling = TypeNameHandling.Objects;
                        todos           = JsonConvert.DeserializeObject <ObservableCollection <TodoItem> >(json.ToString(), settings);
                        settingsCreated = true;
                        if (ApplicationData.Current.LocalSettings.Values.TryGetValue(Last_Todo_ID, out object last))
                        {
                            lastID = (int)last;
                        }
                    }
                    lastID++;
                    TodoItem newTodo = new TodoItem(lastID, todoTitle, "...");
                    todos.Add(newTodo);
                    if (settingsCreated)
                    {
                        ApplicationData.Current.LocalSettings.Values[Local_Settings_Todo] = JsonConvert.SerializeObject(todos);
                        ApplicationData.Current.LocalSettings.Values[Last_Todo_ID]        = lastID;
                    }
                    else
                    {
                        ApplicationData.Current.LocalSettings.Values.Add(Local_Settings_Todo, JsonConvert.SerializeObject(todos));
                        ApplicationData.Current.LocalSettings.Values.Add(Last_Todo_ID, lastID);
                    }

                    //Nuget Packacke UWP.ToastNotification
                    var content = new ToastContent()
                    {
                        // More about the Launch property at https://docs.microsoft.com/dotnet/api/microsoft.toolkit.uwp.notifications.toastcontent
                        Launch = "ToastContentActivationParams",

                        Visual = new ToastVisual()
                        {
                            BindingGeneric = new ToastBindingGeneric()
                            {
                                Children =
                                {
                                    new AdaptiveText()
                                    {
                                        Text = "TODO wurde erstellt!"
                                    },

                                    new AdaptiveText()
                                    {
                                        Text = $"{newTodo.Title}: {newTodo.Description}"
                                    }
                                }
                            }
                        },

                        Actions = new ToastActionsCustom()
                        {
                            Buttons =
                            {
                                // More about Toast Buttons at https://docs.microsoft.com/dotnet/api/microsoft.toolkit.uwp.notifications.toastbutton
                                new ToastButton("Anzeigen", newTodo.ID.ToString())
                                {
                                    ActivationType = ToastActivationType.Foreground
                                },

                                new ToastButtonDismiss("Abbrechen")
                            }
                        }
                    };

                    var toast = new ToastNotification(content.GetXml());
                    ToastNotificationManager.CreateToastNotifier().Show(toast);
                    returnData.Add("Status", "OK");
                    await args.Request.SendResponseAsync(returnData);
                }
            }
            catch (Exception e)
            {
                returnData.Add("Status", e.Message);
                await args.Request.SendResponseAsync(returnData);

                return;
            }
            finally
            {
                messageDeferral?.Complete();
            }
        }
Пример #56
0
        private async void GenerateRandomNumber_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
        {
            //Is there an open connection?
            if (connection == null)
            {
                rootPage.NotifyUser("You need to open a connection before trying to generate a random number.", NotifyType.ErrorMessage);
                return;
            }

            //Parse user input
            int  minValueInput = 0;
            bool valueParsed   = int.TryParse(MinValue.Text, out minValueInput);

            if (!valueParsed)
            {
                rootPage.NotifyUser("The Minimum Value should be a valid integer", NotifyType.ErrorMessage);
                return;
            }

            int maxValueInput = 0;

            valueParsed = int.TryParse(MaxValue.Text, out maxValueInput);
            if (!valueParsed)
            {
                rootPage.NotifyUser("The Maximum Value should be a valid integer", NotifyType.ErrorMessage);
                return;
            }

            if (maxValueInput <= minValueInput)
            {
                rootPage.NotifyUser("Maximum Value must be larger than Minimum Value", NotifyType.ErrorMessage);
                return;
            }

            //Send a message to the app service
            var inputs = new ValueSet();

            inputs.Add("minvalue", minValueInput);
            inputs.Add("maxvalue", maxValueInput);
            AppServiceResponse response = await connection.SendMessageAsync(inputs);

            //If the service responded display the message. We're done!
            if (response.Status == AppServiceResponseStatus.Success)
            {
                if (!response.Message.ContainsKey("result"))
                {
                    rootPage.NotifyUser("The app service response message does not contain a key called \"result\"", NotifyType.StatusMessage);
                    return;
                }

                var resultText = response.Message["result"].ToString();
                if (!string.IsNullOrEmpty(resultText))
                {
                    Result.Text = resultText;
                    rootPage.NotifyUser("App service responded with a result", NotifyType.StatusMessage);
                }
                else
                {
                    rootPage.NotifyUser("App service did not respond with a result", NotifyType.ErrorMessage);
                }
            }
            else
            {
                //Something went wrong. Show the user a meaningful
                //message depending upon the status
                switch (response.Status)
                {
                case AppServiceResponseStatus.Failure:
                    rootPage.NotifyUser("The service failed to acknowledge the message we sent it. It may have been terminated because the client was suspended.", NotifyType.ErrorMessage);
                    break;

                case AppServiceResponseStatus.ResourceLimitsExceeded:
                    rootPage.NotifyUser("The service exceeded the resources allocated to it and had to be terminated.", NotifyType.ErrorMessage);
                    break;

                case AppServiceResponseStatus.Unknown:
                default:
                    rootPage.NotifyUser("An unkown error occurred while we were trying to send a message to the service.", NotifyType.ErrorMessage);
                    break;
                }
            }
        }
Пример #57
0
        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 = Windows.Storage.ApplicationData.Current.LocalSettings;

                    if (arguments == "Terminate")
                    {
                        // Exit fulltrust process (UWP is closed or suspended)
                        appServiceExit.Set();
                        messageDeferral.Complete();
                    }
                    else if (arguments == "RecycleBin")
                    {
                        var action = (string)args.Request.Message["action"];
                        if (action == "Empty")
                        {
                            // Shell function to empty recyclebin
                            Vanara.PInvoke.Shell32.SHEmptyRecycleBin(IntPtr.Zero, null, Vanara.PInvoke.Shell32.SHERB.SHERB_NOCONFIRMATION | Vanara.PInvoke.Shell32.SHERB.SHERB_NOPROGRESSUI);
                        }
                        else if (action == "Query")
                        {
                            var responseQuery = new ValueSet();
                            Win32API.SHQUERYRBINFO queryBinInfo = new Win32API.SHQUERYRBINFO();
                            queryBinInfo.cbSize = (uint)Marshal.SizeOf(typeof(Win32API.SHQUERYRBINFO));
                            var res = Win32API.SHQueryRecycleBin("", ref queryBinInfo);
                            // TODO: use this when updated library is released
                            //Vanara.PInvoke.Shell32.SHQUERYRBINFO queryBinInfo = new Vanara.PInvoke.Shell32.SHQUERYRBINFO();
                            //Vanara.PInvoke.Shell32.SHQueryRecycleBin(null, ref queryBinInfo);
                            if (res == Vanara.PInvoke.HRESULT.S_OK)
                            {
                                var numItems = queryBinInfo.i64NumItems;
                                var binSize  = queryBinInfo.i64Size;
                                responseQuery.Add("NumItems", numItems);
                                responseQuery.Add("BinSize", binSize);
                                await args.Request.SendResponseAsync(responseQuery);
                            }
                        }
                        else if (action == "Enumerate")
                        {
                            // Enumerate recyclebin contents and send response to UWP
                            var responseEnum       = new ValueSet();
                            var folderContentsList = new List <ShellFileItem>();
                            foreach (var folderItem in recycler)
                            {
                                try
                                {
                                    folderItem.Properties.ReadOnly = true;
                                    folderItem.Properties.NoInheritedProperties = false;
                                    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
                                    var    dt            = (System.Runtime.InteropServices.ComTypes.FILETIME)folderItem.Properties[Vanara.PInvoke.Ole32.PROPERTYKEY.System.DateCreated];
                                    var    recycleDate   = dt.ToDateTime().ToLocalTime();     // This is LocalTime
                                    string fileSize      = folderItem.Properties.GetPropertyString(Vanara.PInvoke.Ole32.PROPERTYKEY.System.Size);
                                    ulong  fileSizeBytes = (ulong)folderItem.Properties[Vanara.PInvoke.Ole32.PROPERTYKEY.System.Size];
                                    string fileType      = (string)folderItem.Properties[Vanara.PInvoke.Ole32.PROPERTYKEY.System.ItemTypeText];
                                    bool   isFolder      = folderItem.IsFolder && Path.GetExtension(folderItem.Name) != ".zip";
                                    folderContentsList.Add(new ShellFileItem(isFolder, recyclePath, fileName, filePath, recycleDate, fileSize, fileSizeBytes, fileType));
                                }
                                catch (System.IO.FileNotFoundException)
                                {
                                    // Happens if files are being deleted
                                }
                                finally
                                {
                                    folderItem.Dispose();
                                }
                            }
                            responseEnum.Add("Enumerate", Newtonsoft.Json.JsonConvert.SerializeObject(folderContentsList));
                            await args.Request.SendResponseAsync(responseEnum);
                        }
                    }
                    else if (arguments == "StartupTasks")
                    {
                        // Check QuickLook Availability
                        QuickLook.CheckQuickLookAvailability(localSettings);
                    }
                    else if (arguments == "ToggleQuickLook")
                    {
                        var path = (string)args.Request.Message["path"];
                        QuickLook.ToggleQuickLook(path);
                    }
                    else if (arguments == "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();
                    }
                    else if (args.Request.Message.ContainsKey("Application"))
                    {
                        HandleApplicationLaunch(args);
                    }
                }
                else if (args.Request.Message.ContainsKey("Application"))
                {
                    HandleApplicationLaunch(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();
            }
        }
Пример #58
0
        private async Task HandleShellLibraryMessage(Dictionary <string, object> message)
        {
            switch ((string)message["action"])
            {
            case "Enumerate":
                // Read library information and send response to UWP
                var enumerateResponse = await Win32API.StartSTATask(() =>
                {
                    var response = new ValueSet();
                    try
                    {
                        var libraryItems = new List <ShellLibraryItem>();
                        // https://docs.microsoft.com/en-us/windows/win32/search/-search-win7-development-scenarios#library-descriptions
                        var libFiles = Directory.EnumerateFiles(ShellLibraryItem.LibrariesPath, "*" + ShellLibraryItem.EXTENSION);
                        foreach (var libFile in libFiles)
                        {
                            using var shellItem = ShellItem.Open(libFile);
                            if (shellItem is ShellLibrary library)
                            {
                                libraryItems.Add(ShellFolderExtensions.GetShellLibraryItem(library, libFile));
                            }
                        }
                        response.Add("Enumerate", JsonConvert.SerializeObject(libraryItems));
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Error(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, enumerateResponse, message.Get("RequestID", (string)null));

                break;

            case "Create":
                // Try create new library with the specified name and send response to UWP
                var createResponse = await Win32API.StartSTATask(() =>
                {
                    var response = new ValueSet();
                    try
                    {
                        using var library = new ShellLibrary((string)message["library"], Shell32.KNOWNFOLDERID.FOLDERID_Libraries, false);
                        response.Add("Create", JsonConvert.SerializeObject(ShellFolderExtensions.GetShellLibraryItem(library, library.GetDisplayName(ShellItemDisplayString.DesktopAbsoluteParsing))));
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Error(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, createResponse, message.Get("RequestID", (string)null));

                break;

            case "Update":
                // Update details of the specified library and send response to UWP
                var updateResponse = await Win32API.StartSTATask(() =>
                {
                    var response = new ValueSet();
                    try
                    {
                        var folders           = message.ContainsKey("folders") ? JsonConvert.DeserializeObject <string[]>((string)message["folders"]) : null;
                        var defaultSaveFolder = message.Get("defaultSaveFolder", (string)null);
                        var isPinned          = message.Get("isPinned", (bool?)null);

                        bool updated      = false;
                        var libPath       = (string)message["library"];
                        using var library = ShellItem.Open(libPath) as ShellLibrary;
                        if (folders != null)
                        {
                            if (folders.Length > 0)
                            {
                                var foldersToRemove = library.Folders.Where(f => !folders.Any(folderPath => string.Equals(folderPath, f.FileSystemPath, StringComparison.OrdinalIgnoreCase)));
                                foreach (var toRemove in foldersToRemove)
                                {
                                    library.Folders.Remove(toRemove);
                                    updated = true;
                                }
                                var foldersToAdd = folders.Distinct(StringComparer.OrdinalIgnoreCase)
                                                   .Where(folderPath => !library.Folders.Any(f => string.Equals(folderPath, f.FileSystemPath, StringComparison.OrdinalIgnoreCase)))
                                                   .Select(ShellItem.Open);
                                foreach (var toAdd in foldersToAdd)
                                {
                                    library.Folders.Add(toAdd);
                                    updated = true;
                                }
                                foreach (var toAdd in foldersToAdd)
                                {
                                    toAdd.Dispose();
                                }
                            }
                        }
                        if (defaultSaveFolder != null)
                        {
                            library.DefaultSaveFolder = ShellItem.Open(defaultSaveFolder);
                            updated = true;
                        }
                        if (isPinned != null)
                        {
                            library.PinnedToNavigationPane = isPinned == true;
                            updated = true;
                        }
                        if (updated)
                        {
                            library.Commit();
                            response.Add("Update", JsonConvert.SerializeObject(ShellFolderExtensions.GetShellLibraryItem(library, libPath)));
                        }
                    }
                    catch (Exception e)
                    {
                        Program.Logger.Error(e);
                    }
                    return(response);
                });

                await Win32API.SendMessageAsync(connection, updateResponse, message.Get("RequestID", (string)null));

                break;
            }
        }
Пример #59
0
        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 message    = args.Request.Message;
            ValueSet returnData = new ValueSet();

            string command = message["q"] as string;

            switch (command)
            {
            case "lyric":
                var title = message["title"] as string;
                message.TryGetValue("artist", out object art);
                var artists = art as string;
                message.TryGetValue("album", out object alb);
                var lyalbum = alb as string;

                var localLrc = await LyricSearcher.SearchLrcLocalAsync(title, artists, lyalbum);

                if (!localLrc.IsNullorEmpty())
                {
                    returnData.Add("result", localLrc);

                    returnData.Add("status", 1);
                    break;
                }
                if (message.ContainsKey("ID") && message.ContainsKey("service") && message["service"] as string == "Aurora.Music.Services")
                {
                    var result = await LyricSearcher.GetSongLrcByID(message["ID"] as string);

                    if (!result.IsNullorEmpty())
                    {
                        await LyricSearcher.SaveLrcLocalAsync(title, artists, lyalbum, result);

                        returnData.Add("result", result);
                        returnData.Add("status", 1);
                        break;
                    }
                }
                var substitutes = await LyricSearcher.GetSongLrcListAsync(title, artists);

                if (!substitutes.IsNullorEmpty())
                {
                    var result = await ApiRequestHelper.HttpGet(substitutes.First().Value);

                    if (!result.IsNullorEmpty())
                    {
                        result = HttpUtility.HtmlDecode(result);
                        await LyricSearcher.SaveLrcLocalAsync(title, artists, lyalbum, result);

                        returnData.Add("result", result);
                        returnData.Add("status", 1);
                    }
                    else
                    {
                        returnData.Add("result", null);
                        returnData.Add("status", 0);
                    }
                }
                else
                {
                    returnData.Add("result", null);
                    returnData.Add("status", 0);
                }
                break;

            case "online_music":
                var action = message["action"] as string;
                switch (action)
                {
                case "search":
                    var result = await OnlineMusicSearcher.SearchAsync(message["keyword"] as string);

                    var resultList = new List <PropertySet>();
                    if (result == null && result.Data != null)
                    {
                        returnData.Add("status", 0);
                        break;
                    }

                    foreach (var item in result.Data.Song.ListItems)
                    {
                        var set = new PropertySet
                        {
                            ["title"]        = item.Title,
                            ["description"]  = item.SingerItems[0]?.Title,
                            ["addtional"]    = item.Album.Title,
                            ["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(item.Album.Mid),
                            ["type"]         = "song",
                            ["id"]           = new string[] { item.Mid },
                            ["album_id"]     = item.Album.Mid
                        };
                        resultList.Add(set);
                    }


                    if (!resultList.IsNullorEmpty())
                    {
                        returnData.Add("search_result", JsonConvert.SerializeObject(resultList.ToArray()));
                        returnData.Add("status", 1);
                    }
                    break;

                case "song":
                    var song = await OnlineMusicSearcher.GetSongAsync(message["id"] as string);

                    if (song != null && !song.DataItems.IsNullorEmpty())
                    {
                        DateTime.TryParseExact(song.DataItems[0].Album.Time_Public, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime t);

                        // TODO: property
                        var songRes = new PropertySet
                        {
                            ["title"]       = song.DataItems[0].Title,
                            ["id"]          = song.DataItems[0].Mid,
                            ["album"]       = song.DataItems[0].Album.Name,
                            ["album_id"]    = song.DataItems[0].Album.Mid,
                            ["performers"]  = song.DataItems[0].SingerItems.Select(x => x.Name).ToArray(),
                            ["year"]        = t.Year,
                            ["bit_rate"]    = Settings.Current.GetPreferredBitRate() * 1000,
                            ["track"]       = song.DataItems[0].Index_Album,
                            ["track_count"] = 0,
                            ["duration"]    = TimeSpan.Zero.ToString()
                        };
                        songRes["album_artists"] = songRes["performers"];
                        var picture = OnlineMusicSearcher.GeneratePicturePathByID(song.DataItems[0].Album.Mid);
                        songRes["picture_path"] = picture;
                        songRes["file_url"]     = await OnlineMusicSearcher.GenerateFileUriByID(message["id"] as string, Settings.Current.GetPreferredBitRate());

                        songRes["file_type"] = OnlineMusicSearcher.GenerateFileTypeByID(message["id"] as string, Settings.Current.GetPreferredBitRate());
                        returnData.Add("song_result", JsonConvert.SerializeObject(songRes));
                        returnData.Add("status", 1);
                    }

                    break;

                case "album":
                    var album = await OnlineMusicSearcher.GetAlbumAsync(message["id"] as string);

                    if (album != null && album.Data != null)
                    {
                        DateTime.TryParseExact(album.Data.GetAlbumInfo.Fpublic_Time, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime t);
                        var albumRes = new PropertySet
                        {
                            ["name"]         = album.Data.GetAlbumInfo.Falbum_Name,
                            ["desription"]   = album.Data.GetAlbumDesc.Falbum_Desc.Replace("\n", "\r\n\r\n"),
                            ["year"]         = t.Year,
                            ["track_count"]  = album.Data.GetSongInfoItems.Count,
                            ["disc_count"]   = album.Data.GetSongInfoItems.Max(x => x.Index_Cd) + 1,
                            ["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(message["id"] as string),
                            ["genres"]       = new string[] { album.Data.Genre }
                        };
                        returnData.Add("album_result", JsonConvert.SerializeObject(albumRes));
                        returnData.Add("songs", JsonConvert.SerializeObject(album.Data.GetSongInfoItems.Select(x =>
                        {
                            var p = new PropertySet()
                            {
                                ["id"]           = x.Mid,
                                ["title"]        = x.Name,
                                ["album"]        = x.Album.Name,
                                ["album_id"]     = x.Album.Mid,
                                ["performers"]   = x.SingerItems.Select(y => y.Name).ToArray(),
                                ["year"]         = t.Year,
                                ["bit_rate"]     = Settings.Current.GetPreferredBitRate() * 1000,
                                ["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(x.Album.Mid),
                                ["track"]        = x.Index_Album,
                                ["duration"]     = TimeSpan.Zero.ToString(),
                                ["file_url"]     = AsyncHelper.RunSync(async() => await OnlineMusicSearcher.GenerateFileUriByID(x.Mid, Settings.Current.GetPreferredBitRate())),
                                ["file_type"]    = OnlineMusicSearcher.GenerateFileTypeByID(x.Mid, Settings.Current.GetPreferredBitRate())
                            };
                            p["album_artists"] = p["performers"];
                            return(p);
                        })));
                        returnData.Add("album_artists", JsonConvert.SerializeObject(album.Data.SingerInfoItems.Select(x =>
                        {
                            return(new PropertySet()
                            {
                                ["name"] = x.Fsinger_Name,
                                ["id"] = x.Fsinger_Mid,
                            });
                        })));
                        returnData.Add("status", 1);
                    }
                    break;

                case "artist":
                    var artist = await OnlineMusicSearcher.GetArtistAsync(message["id"] as string);

                    break;

                default:
                    break;
                }
                break;

            case "online_meta":
                var meta_action = message["action"] as string;
                switch (meta_action)
                {
                case "album":
                    var meta_album = await LastfmSearcher.GetAlbumInfo(message["album"] as string, message["artist"] as string);

                    if (meta_album != null)
                    {
                        returnData.Add("status", 1);
                        returnData.Add("album_result", JsonConvert.SerializeObject(new PropertySet()
                        {
                            ["name"]    = meta_album.Name,
                            ["artwork"] = meta_album.AltArtwork?.OriginalString,
                            ["desc"]    = meta_album.Description,
                            ["artist"]  = meta_album.Artist,
                            ["year"]    = meta_album.Year
                        }));
                    }
                    break;

                case "artist":
                    var meta_artist = await LastfmSearcher.GetArtistInfo(message["artist"] as string);

                    if (meta_artist != null)
                    {
                        returnData.Add("status", 1);
                        returnData.Add("artist_result", JsonConvert.SerializeObject(new PropertySet()
                        {
                            ["name"]   = meta_artist.Name,
                            ["avatar"] = meta_artist.AvatarUri?.OriginalString,
                            ["desc"]   = meta_artist.Description,
                        }));
                    }
                    break;
                }
                break;

            default:
                returnData.Add("status", 0);
                break;
            }


            await args.Request.SendResponseAsync(returnData);

            // Return the data to the caller.
            // 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();
        }
Пример #60
0
        private async void ChoosePicture_Click(object sender, RoutedEventArgs e)

        {
            // 创建和自定义 FileOpenPicker
            var picker = new Windows.Storage.Pickers.FileOpenPicker();

            picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; //可通过使用图片缩略图创建丰富的视觉显示,以显示文件选取器中的文件
            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
            picker.FileTypeFilter.Add(".jpg");
            picker.FileTypeFilter.Add(".jpeg");
            picker.FileTypeFilter.Add(".png");
            picker.FileTypeFilter.Add(".gif");

            //选取单个文件

            Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();

            //文件处理
            if (file != null)
            {
                var inputFile   = SharedStorageAccessManager.AddFile(file);
                var destination = await ApplicationData.Current.LocalFolder.CreateFileAsync("Cropped.jpg", CreationCollisionOption.ReplaceExisting);//在应用文件夹中建立文件用来存储裁剪后的图像

                var destinationFile = SharedStorageAccessManager.AddFile(destination);
                var options         = new LauncherOptions();
                options.TargetApplicationPackageFamilyName = "Microsoft.Windows.Photos_8wekyb3d8bbwe";
                //待会要传入的参数


                var parameters = new ValueSet();
                parameters.Add("InputToken", inputFile);                //输入文件
                parameters.Add("DestinationToken", destinationFile);    //输出文件
                parameters.Add("ShowCamera", false);                    //它允许我们显示一个按钮,以允许用户采取当场图象
                parameters.Add("EllipticalCrop", true);                 //截图区域显示为圆(最后截出来还是方形)
                parameters.Add("CropWidthPixals", 300);
                parameters.Add("CropHeightPixals", 300);
                //调用系统自带截图并返回结果
                var result = await Launcher.LaunchUriForResultsAsync(new Uri("microsoft.windows.photos.crop:"), options, parameters);

                //按理说下面这个判断应该没问题呀,但是如果裁剪界面点了取消的话后面会出现异常,所以后面我加了try catch
                if (result.Status == LaunchUriStatus.Success && result.Result != null)
                {
                    //对裁剪后图像的下一步处理
                    try
                    {
                        // 载入已保存的裁剪后图片
                        var stream = await destination.OpenReadAsync();

                        var bitmap = new BitmapImage();
                        await bitmap.SetSourceAsync(stream);

                        // 显示
                        img.ImageSource = bitmap;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message + ex.StackTrace);
                    }
                }
            }
        }