public NotifyUser ( string strMessage, NotifyType type ) : void | ||
strMessage | string | |
type | NotifyType | |
Результат | void |
protected override async void OnNavigatedTo(NavigationEventArgs e) { ResultCollection = new ObservableCollection<WiFiNetworkDisplay>(); rootPage = MainPage.Current; // RequestAccessAsync must have been called at least once by the app before using the API // Calling it multiple times is fine but not necessary // RequestAccessAsync must be called from the UI thread var access = await WiFiAdapter.RequestAccessAsync(); if (access != WiFiAccessStatus.Allowed) { rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage); } else { DataContext = this; var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector()); if (result.Count >= 1) { firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id); RegisterButton.IsEnabled = true; } else { rootPage.NotifyUser("No WiFi Adapters detected on this machine", NotifyType.ErrorMessage); } } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // Clear the messages rootPage.NotifyUser(String.Empty, NotifyType.StatusMessage, true); if (!ApplicationData.Current.RoamingSettings.Values.ContainsKey("DenyIfPhoneLocked")) { ApplicationData.Current.RoamingSettings.Values["DenyIfPhoneLocked"] = false; } if (!ApplicationData.Current.RoamingSettings.Values.ContainsKey("LaunchAboveLock")) { ApplicationData.Current.RoamingSettings.Values["LaunchAboveLock"] = false; } chkDenyIfPhoneLocked.IsChecked = (bool)ApplicationData.Current.RoamingSettings.Values["DenyIfPhoneLocked"]; chkLaunchAboveLock.IsChecked = (bool)ApplicationData.Current.RoamingSettings.Values["LaunchAboveLock"]; if (!(await CheckHceSupport())) { // No HCE support on this device btnRegisterBgTask.IsEnabled = false; btnAddCard.IsEnabled = false; } else { lstCards.ItemsSource = await SmartCardEmulator.GetAppletIdGroupRegistrationsAsync(); } }
/// <summary> /// Clean up the notification area when user navigate to prediction page /// </summary> /// <param name="e">Event data that describes the click action on the button.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // Clean notification area. rootPage.NotifyUser(string.Empty, NotifyType.StatusMessage); }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// /// We will enable/disable parts of the UI if the device doesn't support it. /// </summary> /// <param name="eventArgs">Event data that describes how this page was reached. The Parameter /// property is typically used to configure the page.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // Get the existing task if already registered if (taskRegistration == null) { // Find the task if we previously registered it foreach (var task in BackgroundTaskRegistration.AllTasks.Values) { if (task.Name == taskName) { taskRegistration = task; taskRegistration.Completed += OnBackgroundTaskCompleted; break; } } } else taskRegistration.Completed += OnBackgroundTaskCompleted; // Attach handlers for suspension to stop the watcher when the App is suspended. App.Current.Suspending += App_Suspending; App.Current.Resuming += App_Resuming; rootPage.NotifyUser("Press Run to register watcher.", NotifyType.StatusMessage); }
protected override async void OnNavigatedTo(NavigationEventArgs e) { ResultCollection = new ObservableCollection<WiFiNetworkDisplay>(); rootPage = MainPage.Current; // RequestAccessAsync must have been called at least once by the app before using the API // Calling it multiple times is fine but not necessary // RequestAccessAsync must be called from the UI thread var result = await WiFiAdapter.RequestAccessAsync(); if (result != WiFiAccessStatus.Allowed) { rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage); } else { DataContext = this; wiFiAdapters = await WiFiAdapter.FindAllAdaptersAsync(); int index = 0; foreach (var adapter in wiFiAdapters) { var button = new Button(); button.Tag = index; button.Content = String.Format("WiFi Adapter {0}", ++index); button.Click += Button_Click; Buttons.Children.Add(button); } } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; rootPage.NotifyUser("Waiting for client to connect...", NotifyType.StatusMessage); tcpListener = new StreamSocketListener(); tcpListener.ConnectionReceived += OnConnected; await tcpListener.BindEndpointAsync(null, port); }
protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; try { foreach (var current in BackgroundTaskRegistration.AllTasks) { if (current.Value.Name == "SocketActivityBackgroundTask") { task = current.Value; break; } } // If there is no task allready created, create a new one if (task == null) { var socketTaskBuilder = new BackgroundTaskBuilder(); socketTaskBuilder.Name = "SocketActivityBackgroundTask"; socketTaskBuilder.TaskEntryPoint = "SocketActivityBackgroundTask.SocketActivityTask"; var trigger = new SocketActivityTrigger(); socketTaskBuilder.SetTrigger(trigger); task = socketTaskBuilder.Register(); } SocketActivityInformation socketInformation; if (SocketActivityInformation.AllSockets.TryGetValue(socketId, out socketInformation)) { // Application can take ownership of the socket and make any socket operation // For sample it is just transfering it back. socket = socketInformation.StreamSocket; socket.TransferOwnership(socketId); socket = null; rootPage.NotifyUser("Connected. You may close the application", NotifyType.StatusMessage); TargetServerTextBox.IsEnabled = false; ConnectButton.IsEnabled = false; } } catch (Exception exception) { rootPage.NotifyUser(exception.Message, NotifyType.ErrorMessage); } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { ResultCollection = new ObservableCollection<WiFiNetworkDisplay>(); rootPage = MainPage.Current; // RequestAccessAsync must have been called at least once by the app before using the API // Calling it multiple times is fine but not necessary // RequestAccessAsync must be called from the UI thread var access = await WiFiAdapter.RequestAccessAsync(); if (access != WiFiAccessStatus.Allowed) { rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage); } else { DataContext = this; var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector()); if (result.Count >= 1) { firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id); var scanButton = new Button(); scanButton.Content = string.Format("Scan"); scanButton.Click += ScanButton_Click; Buttons.Children.Add(scanButton); var disconnectButton = new Button(); disconnectButton.Content = string.Format("Disconnect"); disconnectButton.Click += DisconnectButton_Click; ; Buttons.Children.Add(disconnectButton); // Monitor network status changes await UpdateConnectivityStatusAsync(); NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged; } else { rootPage.NotifyUser("No WiFi Adapters detected on this machine", NotifyType.ErrorMessage); } } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // RequestAccessAsync must be called at least once from the UI thread var accessLevel = await Radio.RequestAccessAsync(); if (accessLevel != RadioAccessStatus.Allowed) { rootPage.NotifyUser("App is not allowed to control radios.", NotifyType.ErrorMessage); } else { InitializeRadios(); } }
public SendTextMessage() { this.InitializeComponent(); rootPage = MainPage.Current; _accelerometer = Accelerometer.GetDefault(); if (_accelerometer != null) { // Select a report interval that is both suitable for the purposes of the app and supported by the sensor. // This value will be used later to activate the sensor. uint minReportInterval = _accelerometer.MinimumReportInterval; _desiredReportInterval = minReportInterval > 16 ? minReportInterval : 16; // Set up a DispatchTimer _dispatcherTimer = new DispatcherTimer(); _dispatcherTimer.Tick += DisplayCurrentReading; _dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, (int)_desiredReportInterval); } else { rootPage.NotifyUser("No accelerometer found. This app is not compatible with your device!", NotifyType.ErrorMessage); } }
public async Task SubscribeAsync() { PushNotificationChannel channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync(); channel.PushNotificationReceived += PushNotificationReceived; var result = await apiClient.SubscribeToUserNotificationsAsync(channel); if (result.Status != UserNotificationApiResultStatus.Succeeded) { throw new Exception($"GraphNotificationsSample failed to subscribe for notifications, status: {result.Status}"); } else { // Save the last good subscription rootPage?.NotifyUser($"GraphNotificationsSample subscribed with {result.UserNotificationSubscriptionId} valid till {result.ExpirationDateTime}"); UserNotificationSubscriptionId = result.UserNotificationSubscriptionId; // This App should send "UserNotificationSubscriptionId" to its appservice. // Appservice can use UserNotificationSubscriptionId to POST new notification // to https://graph.microsoft.com/beta/me/notifications without OAuth tokens. } }
/// <summary /// This app is registered as a hanlder for WPD\IMageSourceAutoPlay event. /// When a user connects a WPD device (ie: Camera), OnNavigatedTo is called with DeviceInformationId /// that we can call FromIdAsync() and preselect the device. /// /// We also need to handle the situation where the client was terminated while an import operation was in flight. /// Import will continue and we attempt to reconnect back to the session. /// </summary> /// <param name="e">Details about the NavigationEventArgs</param> protected override async void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); rootPage = MainPage.Current; try { //An photo import session was in progress if (e.Parameter is PhotoImportOperation) { PhotoImportOperation op = e.Parameter as PhotoImportOperation; switch (op.Stage) { // file enumeration was running case PhotoImportStage.FindingItems: cts = new CancellationTokenSource(); rootPage.NotifyUser("Reconnected back to the file enumeration stage", NotifyType.StatusMessage); // Set up progress handler for existing file enumeration var findAllItemsProgress = new Progress<uint>((result) => { rootPage.NotifyUser(String.Format("Found {0} Files", result.ToString()), NotifyType.StatusMessage); }); // retrieve previous session this.session = op.Session; // get to the operation for the existing FindItemsAsync session this.itemsResult = await op.ContinueFindingItemsAsync.AsTask(cts.Token, findAllItemsProgress); // display the items we found in the previous session setIncrementalFileList(this.itemsResult); this.selectAllButton.IsEnabled = true; this.selectNoneButton.IsEnabled = true; this.selectNewButton.IsEnabled = true; this.importButton.IsEnabled = true; DisplayFindItemsResult(); cts = null; break; // Import was running case PhotoImportStage.ImportingItems: rootPage.NotifyUser("Reconnected back to the importing stage.", NotifyType.StatusMessage); setButtonState(false); cts = new CancellationTokenSource(); // Set up progress handler for the existing import session var importSelectedItemsProgress = new Progress<PhotoImportProgress>((result) => { progressBar.Value = result.ImportProgress; }); // retrieve the previous operation this.session = op.Session; // get the itemsResult that were found in the previous session this.itemsResult = await op.ContinueFindingItemsAsync.AsTask(); // hook up the ItemImported Handler to show progress this.itemsResult.ItemImported += async (s, a) => { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser(String.Format("Imported: {0}", a.ImportedItem.Name), NotifyType.StatusMessage); }); }; // Get the operation for the import operation that was in flight this.importedResult = await op.ContinueImportingItemsAsync.AsTask(cts.Token, importSelectedItemsProgress); DisplayImportedSummary(); this.findSourceButton.IsEnabled = true; this.deleteButton.IsEnabled = true; cts = null; break; // Delete operation is in progress case PhotoImportStage.DeletingImportedItemsFromSource: rootPage.NotifyUser("Reconnected to the deletion stage.",NotifyType.StatusMessage); this.findSourceButton.IsEnabled = false; this.deleteButton.IsEnabled = false; cts = new CancellationTokenSource(); var progress = new Progress<double>((result) => { this.progressBar.Value = result; }); // get the operation for the existing delete session this.deleteResult = await op.ContinueDeletingImportedItemsFromSourceAsync.AsTask(cts.Token, progress); DisplayDeletedResults(); if (!deleteResult.HasSucceeded) { rootPage.NotifyUser("Deletion did not succeeded or was cancelled.", NotifyType.StatusMessage); } this.findSourceButton.IsEnabled = true; // Set the CancellationTokenSource to null when the work is complete. cts = null; break; // Idle State. case PhotoImportStage.NotStarted: rootPage.NotifyUser("No import tasks was started.", NotifyType.StatusMessage); this.session = op.Session; break; default: break; } } // Activated by AutoPlay if (e.Parameter is DeviceActivatedEventArgs) { this.arguments = e.Parameter as DeviceActivatedEventArgs; bool importSupported = await PhotoImportManager.IsSupportedAsync(); this.sourceListBox.Items.Clear(); List<PhotoImportSource> source = new List<PhotoImportSource>(); // Create the source from a device Id source.Add(await PhotoImportSource.FromIdAsync(this.arguments.DeviceInformationId)); // bind and preselects source this.sourceListBox.ItemsSource = source; this.sourceListBox.SelectedIndex = 0; rootPage.NotifyUser("Device selected from AutoPlay", NotifyType.StatusMessage); } } catch (Exception ex) { rootPage.NotifyUser("Exception: " + ex.ToString(), NotifyType.ErrorMessage); } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // It is recommended to only retrieve the m_shareOperation object in the activation handler, return as // quickly as possible, and retrieve all data from the share target asynchronously. m_shareOperation = (ShareOperation)e.Parameter; if (m_shareOperation == null) { return; } var result = await ProtectionPolicyManager.RequestAccessAsync(Scenario1.m_enterpriseId, m_shareOperation.Data.Properties.EnterpriseId); if (result == ProtectionPolicyEvaluationResult.Blocked) { rootPage.NotifyUser("\nSharing is blocked by policy from your Enterprise", NotifyType.ErrorMessage); } await Task.Factory.StartNew(async () => { // Retrieve the data package properties. m_sharedDataTitle = m_shareOperation.Data.Properties.Title; m_sharedDataDescription = m_shareOperation.Data.Properties.Description; m_sharedDataPackageFamilyName = m_shareOperation.Data.Properties.PackageFamilyName; m_sharedDataContentSourceWebLink = m_shareOperation.Data.Properties.ContentSourceWebLink; m_sharedDataContentSourceApplicationLink = m_shareOperation.Data.Properties.ContentSourceApplicationLink; m_sharedDataLogoBackgroundColor = m_shareOperation.Data.Properties.LogoBackgroundColor; m_sharedDataSquare30x30Logo = m_shareOperation.Data.Properties.Square30x30Logo; m_sharedThumbnailStreamRef = m_shareOperation.Data.Properties.Thumbnail; shareQuickLinkId = m_shareOperation.QuickLinkId; // Retrieve the data package content. // The GetWebLinkAsync(), GetTextAsync(), GetStorageItemsAsync(), etc. APIs will throw if there was an error retrieving the data from the source app. // In this sample, we just display the error. It is recommended that a share target app handles these in a way appropriate for that particular app. if (m_shareOperation.Data.Contains(StandardDataFormats.WebLink)) { try { m_sharedWebLink = await m_shareOperation.Data.GetWebLinkAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(StandardDataFormats.ApplicationLink)) { try { m_sharedApplicationLink = await m_shareOperation.Data.GetApplicationLinkAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetApplicationLinkAsync - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(StandardDataFormats.Text)) { try { m_sharedText = await m_shareOperation.Data.GetTextAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetTextAsync - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(StandardDataFormats.StorageItems)) { try { m_sharedStorageItems = await m_shareOperation.Data.GetStorageItemsAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetStorageItemsAsync - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(dataFormatName)) { try { m_sharedCustomData = await m_shareOperation.Data.GetTextAsync(dataFormatName); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetTextAsync(" + dataFormatName + ") - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(StandardDataFormats.Html)) { try { m_sharedHtmlFormat = await m_shareOperation.Data.GetHtmlFormatAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetHtmlFormatAsync - " + ex.Message, NotifyType.ErrorMessage); } try { m_sharedResourceMap = await m_shareOperation.Data.GetResourceMapAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetResourceMapAsync - " + ex.Message, NotifyType.ErrorMessage); } } if (m_shareOperation.Data.Contains(StandardDataFormats.Bitmap)) { try { m_sharedBitmapStreamRef = await m_shareOperation.Data.GetBitmapAsync(); } catch (Exception ex) { NotifyUserBackgroundThread("Failed GetBitmapAsync - " + ex.Message, NotifyType.ErrorMessage); } } // In this sample, we just display the m_shared data content. // Get back to the UI thread using the dispatcher. await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => { DataPackageTitle.Text = m_sharedDataTitle; DataPackageDescription.Text = m_sharedDataDescription; DataPackagePackageFamilyName.Text = m_sharedDataPackageFamilyName; if (m_sharedDataContentSourceWebLink != null) { DataPackageContentSourceWebLink.Text = m_sharedDataContentSourceWebLink.AbsoluteUri; } if (m_sharedDataContentSourceApplicationLink != null) { DataPackageContentSourceApplicationLink.Text = m_sharedDataContentSourceApplicationLink.AbsoluteUri; } if (m_sharedDataSquare30x30Logo != null) { IRandomAccessStreamWithContentType logoStream = await m_sharedDataSquare30x30Logo.OpenReadAsync(); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(logoStream); LogoHolder.Source = bitmapImage; LogoBackground.Background = new SolidColorBrush(m_sharedDataLogoBackgroundColor); LogoArea.Visibility = Visibility.Visible; } if (!String.IsNullOrEmpty(m_shareOperation.QuickLinkId)) { SelectedQuickLinkId.Text = shareQuickLinkId; } if (m_sharedThumbnailStreamRef != null) { IRandomAccessStreamWithContentType thumbnailStream = await m_sharedThumbnailStreamRef.OpenReadAsync(); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(thumbnailStream); ThumbnailHolder.Source = bitmapImage; ThumbnailArea.Visibility = Visibility.Visible; } if (m_sharedWebLink != null) { AddContentValue("WebLink: ", m_sharedWebLink.AbsoluteUri); } if (m_sharedApplicationLink != null) { AddContentValue("ApplicationLink: ", m_sharedApplicationLink.AbsoluteUri); } if (m_sharedText != null) { AddContentValue("Text: ", m_sharedText); } if (m_sharedStorageItems != null) { // Display the name of the files being m_shared. StringBuilder fileNames = new StringBuilder(); for (int index = 0; index < m_sharedStorageItems.Count; index++) { fileNames.Append(m_sharedStorageItems[index].Name); if (index < m_sharedStorageItems.Count - 1) { fileNames.Append(", "); } } fileNames.Append("."); AddContentValue("StorageItems: ", fileNames.ToString()); } if (m_sharedCustomData != null) { // This is an area to be especially careful parsing data from the source app to avoid buffer overruns. // This sample doesn't perform data validation but will catch any exceptions thrown. try { StringBuilder receivedStrings = new StringBuilder(); JsonObject customObject = JsonObject.Parse(m_sharedCustomData); if (customObject.ContainsKey("type")) { if (customObject["type"].GetString() == "http://schema.org/Book") { // This sample expects the custom format to be of type http://schema.org/Book receivedStrings.AppendLine("Type: " + customObject["type"].Stringify()); JsonObject properties = customObject["properties"].GetObject(); receivedStrings.AppendLine("Image: " + properties["image"].Stringify()); receivedStrings.AppendLine("Name: " + properties["name"].Stringify()); receivedStrings.AppendLine("Book Format: " + properties["bookFormat"].Stringify()); receivedStrings.AppendLine("Author: " + properties["author"].Stringify()); receivedStrings.AppendLine("Number of Pages: " + properties["numberOfPages"].Stringify()); receivedStrings.AppendLine("Publisher: " + properties["publisher"].Stringify()); receivedStrings.AppendLine("Date Published: " + properties["datePublished"].Stringify()); receivedStrings.AppendLine("In Language: " + properties["inLanguage"].Stringify()); receivedStrings.Append("ISBN: " + properties["isbn"].Stringify()); AddContentValue("Custom format data:" + Environment.NewLine, receivedStrings.ToString()); } else { rootPage.NotifyUser("The custom format from the source app is not of type http://schema.org/Book", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("The custom format from the source app doesn't contain a type", NotifyType.ErrorMessage); } } catch (Exception ex) { rootPage.NotifyUser("Failed to parse the custom data - " + ex.Message, NotifyType.ErrorMessage); } } if (m_sharedHtmlFormat != null) { string htmlFragment = HtmlFormatHelper.GetStaticFragment(m_sharedHtmlFormat); if (!String.IsNullOrEmpty(htmlFragment)) { AddContentValue("HTML: "); ShareWebView.Visibility = Visibility.Visible; ShareWebView.NavigateToString("<html><body>" + htmlFragment + "</body></html>"); } else { rootPage.NotifyUser("GetStaticFragment failed to parse the HTML from the source app", NotifyType.ErrorMessage); } // Check if there are any local images in the resource map. if (m_sharedResourceMap.Count > 0) { //ResourceMapValue.Text = ""; foreach (KeyValuePair<string, RandomAccessStreamReference> item in m_sharedResourceMap) { ResourceMapValue.Text += "\nKey: " + item.Key; } ResourceMapArea.Visibility = Visibility.Visible; } } if (m_sharedBitmapStreamRef != null) { IRandomAccessStreamWithContentType bitmapStream = await m_sharedBitmapStreamRef.OpenReadAsync(); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(bitmapStream); ImageHolder.Source = bitmapImage; ImageArea.Visibility = Visibility.Visible; } }); }); }
private async void PurchaseAddOnButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e) { var item = (ItemDetails)ProductsListView.SelectedItem; StorePurchaseResult result = await storeContext.RequestPurchaseAsync(item.StoreId); if (result.ExtendedError != null) { Utils.ReportExtendedError(result.ExtendedError); return; } switch (result.Status) { case StorePurchaseStatus.AlreadyPurchased: // should never get this for a managed consumable since they are stackable rootPage.NotifyUser($"You already bought this consumable.", NotifyType.ErrorMessage); break; case StorePurchaseStatus.Succeeded: rootPage.NotifyUser($"You bought {item.Title}.", NotifyType.StatusMessage); break; case StorePurchaseStatus.NotPurchased: rootPage.NotifyUser("Product was not purchased, it may have been canceled.", NotifyType.ErrorMessage); break; case StorePurchaseStatus.NetworkError: rootPage.NotifyUser("Product was not purchased due to a network error.", NotifyType.ErrorMessage); break; case StorePurchaseStatus.ServerError: rootPage.NotifyUser("Product was not purchased due to a server error.", NotifyType.ErrorMessage); break; default: rootPage.NotifyUser("Product was not purchased due to an unknown error.", NotifyType.ErrorMessage); break; } }
private async void CreateFileButton_Click(object sender, RoutedEventArgs e) { rootPage.NotifyUser("", NotifyType.StatusMessage); FileSavePicker savePicker = new FileSavePicker(); savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; savePicker.FileTypeChoices.Add("Plain Text", new string[] { ".txt" }); savePicker.SuggestedFileName = "New Document"; m_afterWriteFile = await savePicker.PickSaveFileAsync(); if (m_afterWriteFile != null) { rootPage.NotifyUser("File created.", NotifyType.StatusMessage); } else { rootPage.NotifyUser("Operation cancelled.", NotifyType.ErrorMessage); } UpdateButtons(); }
protected override async void OnNavigatedFrom(NavigationEventArgs e) { var success = await ClearBluetoothLEDeviceAsync(); if (!success) { rootPage.NotifyUser("Error: Unable to reset app state", NotifyType.ErrorMessage); } }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// </summary> /// <param name="e">Event data that describes how this page was reached. The Parameter /// property is typically used to configure the page.</param> protected override async void OnNavigatedTo(NavigationEventArgs e) { await MainPage.ConfigureSimulatorAsync("in-app-purchase-consumables.xml"); try { ListingInformation listing = await CurrentAppSimulator.LoadListingInformationAsync(); var product1 = listing.ProductListings["product1"]; Product1Name.Text = product1.Name; Product1Price.Text = product1.FormattedPrice; rootPage.NotifyUser("", NotifyType.StatusMessage); } catch (Exception) { rootPage.NotifyUser("LoadListingInformationAsync API call failed", NotifyType.ErrorMessage); } }
/// <summary> /// Callback function for the invocation of the dialog commands. /// </summary> /// <param name="command">The command that was invoked.</param> private void CommandInvokedHandler(IUICommand command) { // Display message showing the label of the command that was invoked rootPage.NotifyUser("The '" + command.Label + "' command has been selected.", NotifyType.StatusMessage); }
public Scenario1_DeviceUse() { this.InitializeComponent(); Accelerometer = Accelerometer.GetDefault(); if (null != Accelerometer) { // Save trigger so that we may start the background task later. // Only one instance of the trigger can exist at a time. Since the trigger does not implement // IDisposable, it may still be in memory when a new trigger is created. _deviceUseTrigger = new DeviceUseTrigger(); // Setup a timer to periodically refresh results when the app is visible. _refreshTimer = new DispatcherTimer() { Interval = new TimeSpan(0, 0, 1) // Refresh once every second }; _refreshTimer.Tick += RefreshTimer_Tick; } else { rootPage.NotifyUser("No accelerometer found", NotifyType.StatusMessage); } }
private void btnStartAdvertisement_Click(object sender, RoutedEventArgs e) { _publisher = new WiFiDirectAdvertisementPublisher(); _publisher.StatusChanged += OnStatusChanged; _listener = new WiFiDirectConnectionListener(); if (chkListener.IsChecked.Value) { try { // This can raise an exception if the machine does not support WiFi. Sorry. _listener.ConnectionRequested += OnConnectionRequested; } catch (Exception ex) { rootPage.NotifyUser($"Error preparing Advertisement: {ex}", NotifyType.ErrorMessage); return; } } var discoverability = Utils.GetSelectedItemTag <WiFiDirectAdvertisementListenStateDiscoverability>(cmbListenState); _publisher.Advertisement.ListenStateDiscoverability = discoverability; _publisher.Advertisement.IsAutonomousGroupOwnerEnabled = chkPreferGroupOwnerMode.IsChecked.Value; // Legacy settings are meaningful only if IsAutonomousGroupOwnerEnabled is true. if (_publisher.Advertisement.IsAutonomousGroupOwnerEnabled && chkLegacySetting.IsChecked.Value) { _publisher.Advertisement.LegacySettings.IsEnabled = true; if (!String.IsNullOrEmpty(txtPassphrase.Text)) { var creds = new Windows.Security.Credentials.PasswordCredential(); creds.Password = txtPassphrase.Text; _publisher.Advertisement.LegacySettings.Passphrase = creds; } if (!String.IsNullOrEmpty(txtSsid.Text)) { _publisher.Advertisement.LegacySettings.Ssid = txtSsid.Text; } } // Add the information elements. foreach (WiFiDirectInformationElement informationElement in _informationElements) { _publisher.Advertisement.InformationElements.Add(informationElement); } _publisher.Start(); if (_publisher.Status == WiFiDirectAdvertisementPublisherStatus.Started) { btnStartAdvertisement.IsEnabled = false; btnStopAdvertisement.IsEnabled = true; rootPage.NotifyUser("Advertisement started.", NotifyType.StatusMessage); } else { rootPage.NotifyUser($"Advertisement failed to start. Status is {_publisher.Status}", NotifyType.ErrorMessage); } }
private async void ShowProperties() { var selectedUser = (UserViewModel)UserList.SelectedValue; if (selectedUser != null) { ResultsText.Text = ""; ProfileImage.Source = null; rootPage.NotifyUser("", NotifyType.StatusMessage); try { User user = User.GetFromId(selectedUser.UserId); IBuffer aa = SystemIdentification.GetSystemIdForUser(user).Id; IBuffer bb = SystemIdentification.GetSystemIdForUser(null).Id; var aaS = SystemIdentification.GetSystemIdForUser(user).Id.ToArray(); var bbS = SystemIdentification.GetSystemIdForUser(null).Id.ToArray(); Debug.WriteLine("!!!" + aa + "~~~~~~~~~" + bb); // Start with some fixed properties. String result = "NonRoamableId: " + user.NonRoamableId + "\n"; result += "Type: " + user.Type.ToString() + "\n"; result += "AuthenticationStatus: " + user.AuthenticationStatus.ToString() + "\n"; // Build a list of all the properties we want. String[] desiredProperties = new String[] { KnownUserProperties.FirstName, KnownUserProperties.LastName, KnownUserProperties.ProviderName, KnownUserProperties.AccountName, KnownUserProperties.GuestHost, KnownUserProperties.PrincipalName, KnownUserProperties.DomainName, KnownUserProperties.SessionInitiationProtocolUri, }; // Issue a bulk query for all of the properties. IPropertySet values = await user.GetPropertiesAsync(desiredProperties); // Add those properties to our results. foreach (String property in desiredProperties) { result += property + ": " + values[property] + "\n"; } ResultsText.Text = result; // Get the user's picture. IRandomAccessStreamReference streamReference = await user.GetPictureAsync(UserPictureSize.Size64x64); if (streamReference != null) { IRandomAccessStream stream = await streamReference.OpenReadAsync(); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(stream); ProfileImage.Source = bitmapImage; } } catch (Exception ex) { rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage); } } }
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; } } }
protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; rootPage.NotifyUser("Windows Phone doesn’t currently support this function.", NotifyType.ErrorMessage); }
private void UpdateStatus(string status, NotifyType statusType) { m_rootPage.NotifyUser(status, statusType); }
/// <summary> /// Starts previewing the selected scanner's video feed and prevents the display from going to sleep. /// </summary> private async Task StartMediaCaptureAsync(string videoDeviceId) { mediaCapture = new MediaCapture(); // Register for a notification when something goes wrong mediaCapture.Failed += MediaCapture_Failed; var settings = new MediaCaptureInitializationSettings { VideoDeviceId = videoDeviceId, StreamingCaptureMode = StreamingCaptureMode.Video, }; // Initialize MediaCapture bool captureInitialized = false; try { await mediaCapture.InitializeAsync(settings); captureInitialized = true; } catch (UnauthorizedAccessException) { rootPage.NotifyUser("The app was denied access to the camera", NotifyType.ErrorMessage); } catch (Exception e) { rootPage.NotifyUser("Failed to initialize the camera: " + e.Message, NotifyType.ErrorMessage); } if (captureInitialized) { // Prevent the device from sleeping while the preview is running. displayRequest.RequestActive(); PreviewControl.Source = mediaCapture; await mediaCapture.StartPreviewAsync(); await SetPreviewRotationAsync(DisplayInformation.GetForCurrentView().CurrentOrientation); IsPreviewing = true; RaisePropertyChanged(nameof(IsPreviewing)); } else { mediaCapture.Dispose(); mediaCapture = null; } //check if cart is active //if so, start capturing //NEW CODE if (claimedScanner != null) { await claimedScanner.StartSoftwareTriggerAsync(); SoftwareTriggerStarted = true; RaisePropertyChanged(nameof(SoftwareTriggerStarted)); } }
private void btnWatcher_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e) { if (_fWatcherStarted == false) { btnWatcher.Content = "Stop Watcher"; _fWatcherStarted = true; _discoveredDevices.Clear(); rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage); _deviceWatcher = null; String deviceSelector = WiFiDirectDevice.GetDeviceSelector((cmbDeviceSelector.ToString().Equals("Device Interface") == true) ? WiFiDirectDeviceSelectorType.DeviceInterface : WiFiDirectDeviceSelectorType.AssociationEndpoint); _deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" }); _deviceWatcher.Added += OnDeviceAdded; _deviceWatcher.Removed += OnDeviceRemoved; _deviceWatcher.Updated += OnDeviceUpdated; _deviceWatcher.EnumerationCompleted += OnEnumerationCompleted; _deviceWatcher.Stopped += OnStopped; _deviceWatcher.Start(); } else { btnWatcher.Content = "Start Watcher"; _fWatcherStarted = false; _deviceWatcher.Added -= OnDeviceAdded; _deviceWatcher.Removed -= OnDeviceRemoved; _deviceWatcher.Updated -= OnDeviceUpdated; _deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted; _deviceWatcher.Stopped -= OnStopped; _deviceWatcher.Stop(); } }
private async Task ConnectAsync() { if (String.IsNullOrEmpty(InputField.Text)) { rootPage.NotifyUser("Please specify text to send", NotifyType.ErrorMessage); return; } // Validating the URI is required since it was received from an untrusted source (user input). // The URI is validated by calling TryGetUri() that will return null for strings that are not // valid WebSocket URIs. // Note that when enabling the text box users may provide URIs to machines on the intrAnet // or intErnet. In these cases the app requires the "Private Networks (Client and Server)" or // "Internet (Client)" capability respectively. Uri server = rootPage.TryGetUri(ServerAddressField.Text); if (server == null) { return; } messageWebSocket = new MessageWebSocket(); messageWebSocket.Control.MessageType = SocketMessageType.Utf8; messageWebSocket.MessageReceived += MessageReceived; messageWebSocket.Closed += OnClosed; // If we are connecting to wss:// endpoint, by default, the OS performs validation of // the server certificate based on well-known trusted CAs. We can perform additional custom // validation if needed. if (SecureWebSocketCheckBox.IsChecked == true) { // WARNING: Only test applications should ignore SSL errors. // In real applications, ignoring server certificate errors can lead to Man-In-The-Middle // attacks. (Although the connection is secure, the server is not authenticated.) // Note that not all certificate validation errors can be ignored. // In this case, we are ignoring these errors since the certificate assigned to the localhost // URI is self-signed and has subject name = fabrikam.com messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted); messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName); // Add event handler to listen to the ServerCustomValidationRequested event. This enables performing // custom validation of the server certificate. The event handler must implement the desired // custom certificate validation logic. messageWebSocket.ServerCustomValidationRequested += OnServerCustomValidationRequested; // Certificate validation occurs only for secure connections. if (server.Scheme != "wss") { AppendOutputLine("Note: Certificate validation is performed only for the wss: scheme."); } } AppendOutputLine($"Connecting to {server}..."); try { await messageWebSocket.ConnectAsync(server); } catch (Exception ex) // For debugging { // Error happened during connect operation. messageWebSocket.Dispose(); messageWebSocket = null; AppendOutputLine(MainPage.BuildWebSocketError(ex)); AppendOutputLine(ex.Message); return; } // The default DataWriter encoding is Utf8. messageWriter = new DataWriter(messageWebSocket.OutputStream); rootPage.NotifyUser("Connected", NotifyType.StatusMessage); }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// /// We will enable/disable parts of the UI if the device doesn't support it. /// </summary> /// <param name="eventArgs">Event data that describes how this page was reached. The Parameter /// property is typically used to configure the page.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // Attach a handler to process the received advertisement. // The watcher cannot be started without a Received handler attached watcher.Received += OnAdvertisementReceived; // Attach a handler to process watcher stopping due to various conditions, // such as the Bluetooth radio turning off or the Stop method was called watcher.Stopped += OnAdvertisementWatcherStopped; // Attach handlers for suspension to stop the watcher when the App is suspended. App.Current.Suspending += App_Suspending; App.Current.Resuming += App_Resuming; rootPage.NotifyUser("Press Run to start watcher.", NotifyType.StatusMessage); }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// /// We will enable/disable parts of the UI if the device doesn't support it. /// </summary> /// <param name="eventArgs">Event data that describes how this page was reached. The Parameter /// property is typically used to configure the page.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { rootPage = MainPage.Current; // Attach a event handler to monitor the status of the publisher, which // can tell us whether the advertising has been serviced or is waiting to be serviced // due to lack of resources. It will also inform us of unexpected errors such as the Bluetooth // radio being turned off by the user. publisher.StatusChanged += OnPublisherStatusChanged; // Attach handlers for suspension to stop the publisher when the App is suspended. App.Current.Suspending += App_Suspending; App.Current.Resuming += App_Resuming; rootPage.NotifyUser("Press Run to start publisher.", NotifyType.StatusMessage); }
private async void ConnectButton_Click() { ConnectButton.IsEnabled = false; ClearBluetoothLEDevice(); try { // BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent. bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(rootPage.SelectedBleDeviceId); } catch (Exception ex) when((uint)ex.HResult == 0x800710df) { // ERROR_DEVICE_NOT_AVAILABLE because the Bluetooth radio is not on. } if (bluetoothLeDevice != null) { // BT_Code: GattServices returns a list of all the supported services of the device. // If the services supported by the device are expected to change // during BT usage, subscribe to the GattServicesChanged event. foreach (var service in bluetoothLeDevice.GattServices) { ServiceCollection.Add(new BluetoothLEAttributeDisplay(service)); } ConnectButton.Visibility = Visibility.Collapsed; ServiceList.Visibility = Visibility.Visible; } else { ClearBluetoothLEDevice(); rootPage.NotifyUser("Failed to connect to device.", NotifyType.ErrorMessage); } ConnectButton.IsEnabled = true; }
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args) { rootPage.NotifyUser(args.Strokes.Count + " stroke(s) erased!", NotifyType.StatusMessage); }
private async void PublishButton_ClickAsync() { // Server not initialized yet - initialize it and start publishing if (serviceProvider == null) { var serviceStarted = await ServiceProviderInitAsync(); if (serviceStarted) { rootPage.NotifyUser("Service successfully started", NotifyType.StatusMessage); PublishButton.Content = "Stop Service"; } else { rootPage.NotifyUser("Service not started", NotifyType.ErrorMessage); } } else { // BT_Code: Stops advertising support for custom GATT Service serviceProvider.StopAdvertising(); serviceProvider = null; PublishButton.Content = "Start Service"; } }
private async void Start_Click(object sender, RoutedEventArgs e) { Uri resourceUri; // The value of 'AddressField' is set by the user and is therefore untrusted input. If we can't create a // valid, absolute URI, we'll notify the user about the incorrect input. if (!Helpers.TryGetUri(AddressField.Text, out resourceUri)) { rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage); return; } Helpers.ScenarioStarted(StartButton, CancelButton, OutputField); rootPage.NotifyUser("In progress", NotifyType.StatusMessage); if (ReadDefaultRadio.IsChecked.Value) { filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.Default; } else if (ReadMostRecentRadio.IsChecked.Value) { filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent; } else if (ReadOnlyFromCacheRadio.IsChecked.Value) { filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.OnlyFromCache; } else if (ReadNoCacheRadio.IsChecked.Value) { filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.NoCache; } if (WriteDefaultRadio.IsChecked.Value) { filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.Default; } else if (WriteNoCacheRadio.IsChecked.Value) { filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache; } // --------------------------------------------------------------------------- // WARNING: Only test applications should ignore SSL errors. // In real applications, ignoring server certificate errors can lead to MITM // attacks (while the connection is secure, the server is not authenticated). // // The SetupServer script included with this sample creates a server certificate that is self-signed // and issued to fabrikam.com, and hence we need to ignore these errors here. // --------------------------------------------------------------------------- filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted); filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName); // This sample uses a "try" in order to support TaskCanceledException. // If you don't need to support cancellation, then the "try" is not needed. try { HttpRequestResult result = await httpClient.TryGetAsync(resourceUri).AsTask(cts.Token); if (result.Succeeded) { isFilterUsed = true; await Helpers.DisplayTextResultAsync(result.ResponseMessage, OutputField, cts.Token); rootPage.NotifyUser( "Completed. Response came from " + result.ResponseMessage.Source + ". HTTP version used: " + result.ResponseMessage.Version.ToString() + ".", NotifyType.StatusMessage); } else { Helpers.DisplayWebError(rootPage, result.ExtendedError); } } catch (TaskCanceledException) { rootPage.NotifyUser("Request canceled.", NotifyType.ErrorMessage); } Helpers.ScenarioCompleted(StartButton, CancelButton); }