// This event handler is called when the Account settings pane is to be launched.
private async void OnAccountCommandsRequested(
AccountsSettingsPane sender,
AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
// This scenario only lets the user have one account at a time.
// If there already is an account, we do not include a provider in the list
// This will prevent the add account button from showing up.
bool isPresent = ApplicationData.Current.LocalSettings.Values.ContainsKey(StoredAccountKey);
if (isPresent)
{
await AddWebAccount(e);
}
else
{
await AddWebAccountProvider(e);
}
AddLinksAndDescription(e);
deferral.Complete();
}
void MainPage_AccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs args)
{
// Callback invoked to request the app for accounts when the accounts flyout is about to be displayed
// Get the Deferral object and do some async operation if needed
var Deferral = args.GetDeferral();
// do some async operation
//Uri uri = new Uri("ms-appx:///Assets/Smalllogo.png");
//StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri);
// Add CredLocker Credentials
CredentialCommandCredentialDeletedHandler credDeletedHandler = new CredentialCommandCredentialDeletedHandler(CredentialDeletedHandler);
Windows.Security.Credentials.PasswordVault vault = new Windows.Security.Credentials.PasswordVault();
IReadOnlyList<PasswordCredential> creds = vault.RetrieveAll();
if (creds.Count == 0)
args.HeaderText = "There is not credential saved by the sample app, please go to Scenario 1 and add some credential, then try again.";
else
args.HeaderText = "Here are the credentials saved by sample app in Scenario 1.";
foreach (PasswordCredential c in creds)
{
try
{
CredentialCommand credCommand1 = new CredentialCommand(c, credDeletedHandler);
// Deleted is invoked after the system deletes the credential
args.CredentialCommands.Add(credCommand1);
}
catch (Exception Error) // Stored credential was deleted
{
DebugPrint(Error.ToString());
}
}
try
{
// Add Global commands
Object commandID = 1;
UICommandInvokedHandler appCmdInvokedHandler = new UICommandInvokedHandler(CommandInvokedHandler);
// SettingsCommand is an existing WinRT class used in the SettingsPane
SettingsCommand command = new SettingsCommand(
commandID,
"App Specific Command Label...",
appCmdInvokedHandler);
args.Commands.Add(command);
// Add more commands here
}
catch (Exception Error) // No stored credentials, so none to delete
{
DebugPrint(Error.Message);
}
// Complete the Deferral()
Deferral.Complete();
}
public Scenario5()
{
this.InitializeComponent();
InitializeWebAccountProviders();
InitializeWebAccounts();
SettingsPane.GetForCurrentView().CommandsRequested += CommandsRequested;
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += AccountCommandsRequested;
}
private async void SignIn_button_Click(object sender, RoutedEventArgs e)
{
OutputPanel.Visibility = Visibility.Collapsed;
GetStarted_sp.Visibility = Visibility.Visible;
SignInWindows_button.IsEnabled = false;
AccountsSettingsPane.Show();
await Task.Delay(1000);
SignInWindows_button.IsEnabled = true;
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
rootPage = MainPage.Current;
CreateLocalDataContainers();
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += OnAccountCommandsRequested;
IdentityChecker.SampleIdentityConfigurationCorrect(NotRegisteredWarning, AzureActiveDirectoryClientId);
}
/// <summary>
/// Clean up after displaying the web account manager.
/// </summary>
private void Cleanup()
{
if (this.ShowingUI)
{
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested -= OnAccountCommandsRequested;
}
this.ShowingUI = false;
_successHandler = null;
_failedHandler = null;
}
private void Button_ShowAccountSettings(object sender, RoutedEventArgs e)
{
((Button)sender).IsEnabled = false;
rootPage.NotifyUser("Launching AccountSettingsPane", NotifyType.StatusMessage);
AccountsSettingsPane.Show();
((Button)sender).IsEnabled = true;
}
#pragma warning disable VSTHRD100 // Avoid async void methods
private async void Authenticator_AccountCommandsRequested(
#pragma warning restore VSTHRD100 // Avoid async void methods
AccountsSettingsPane sender,
AccountsSettingsPaneCommandsRequestedEventArgs args)
{
AccountsSettingsPaneEventDeferral deferral = null;
try
{
deferral = args.GetDeferral();
if (!string.IsNullOrEmpty(_optionalHeaderText))
{
args.HeaderText = _optionalHeaderText;
}
if (string.Equals("common", _authority.TenantId))
{
_logger.Verbose("Displaying selector for common");
await AddSelectorsAsync(
args,
addOrgAccounts : true,
addMsaAccounts : true).ConfigureAwait(true);
}
else if (string.Equals("organizations", _authority.TenantId))
{
_logger.Verbose("Displaying selector for organizations");
await AddSelectorsAsync(
args,
addOrgAccounts : true,
addMsaAccounts : _isMsaPassthrough).ConfigureAwait(true);
}
else if (string.Equals("consumers", _authority.TenantId))
{
_logger.Verbose("Displaying selector for consumers");
await AddSelectorsAsync(
args,
addOrgAccounts : false,
addMsaAccounts : true).ConfigureAwait(true);
}
else
{
_logger.Verbose("Displaying selector for tenanted authority");
await AddSelectorsAsync(
args,
addOrgAccounts : true,
addMsaAccounts : _isMsaPassthrough,
tenantId : _authority.AuthorityInfo.CanonicalAuthority).ConfigureAwait(true);
}
}
finally
{
deferral?.Complete();
}
}
/// <summary>
/// Displays the Web Account Manager for users to chose an account to authenticate with.
/// </summary>
/// <param name="successHandler">Call back for when an account is successfully choosen by the user.</param>
/// <param name="failedHandler">Call back for when an error or cancelled UI occurs by the user.</param>
public void Show(WebAccountManangerSuccessHandler successHandler, WebAccountManangerFailedHandler failedHandler)
{
if (this.ShowingUI == false)
{
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += OnAccountCommandsRequested;
}
this.ShowingUI = true;
_successHandler = successHandler;
_failedHandler = failedHandler;
AccountsSettingsPane.Show();
}
private void Manage_Click(object sender, RoutedEventArgs e)
{
try
{
AccountsSettingsPane.Show();
}
catch (Exception Error) // No stored credentials, so none to delete
{
DebugPrint(Error.Message);
}
}
public void RequestInteractiveSignIn(string[] scopes, string[]?extraScopes = null)
{
// Ref for this method and all the related private methods below
// https://github.com/microsoft/Windows-universal-samples/blob/master/Samples/WebAccountManagement/cs/SingleMicrosoftAccountScenario.xaml.cs
var pane = AccountsSettingsPane.GetForCurrentView();
pane.AccountCommandsRequested -= OnAccountCommandsRequested;
pane.AccountCommandsRequested += OnAccountCommandsRequested;
AccountsSettingsPane.Show();
}
private async void MainPage_AccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs args)
{
var d = args.GetDeferral();
var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
"https://login.microsoft.com",
"consumers");
var command = new WebAccountProviderCommand(msaProvider, GetMsaTokenAsync);
args.WebAccountProviderCommands.Add(command);
d.Complete();
}
public async void Login()
{
if (await TryGetTokenSilentlyAsync())
{
LoginComplete?.Invoke(this, EventArgs.Empty);
return;
}
else
{
AccountsSettingsPane.Show();
}
}
/// <summary>
/// Logs the user in.
/// </summary>
public async void LoginClick()
{
if (ApplicationData.Current.RoamingSettings.Values.ContainsKey("IsLoggedIn") &&
(bool)ApplicationData.Current.RoamingSettings.Values["IsLoggedIn"])
{
await LoginAsync();
}
else
{
AccountsSettingsPane.Show();
}
}
private async void BuildPaneAsync(AccountsSettingsPane s,
AccountsSettingsPaneCommandsRequestedEventArgs e)
{
var deferral = e.GetDeferral();
var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
"https://login.microsoft.com", "consumers");
var command = new WebAccountProviderCommand(msaProvider, GetMsaTokenAsync);
e.WebAccountProviderCommands.Add(command);
deferral.Complete();
}
public TodoPage()
{
this.InitializeComponent();
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += navigationHelper_LoadState;
this.navigationHelper.SaveState += navigationHelper_SaveState;
this.TodoPageModel = new TodoPageModel();
this.DataContext = this.TodoPageModel;
this.accountSettings = new AccountSettings();
SettingsPane.GetForCurrentView().CommandsRequested += accountSettings.CommandsRequested;
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += accountSettings.AccountCommandsRequested;
}
private async void OnAccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(ProviderId, Authority);
WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, WebAccountProviderCommandInvoked);
e.WebAccountProviderCommands.Add(providerCommand);
deferral.Complete();
}
private async Task <WebTokenRequestResult> SignInAsync(string resource)
{
var taskCompletionSource = new TaskCompletionSource <WebTokenRequestResult>();
TypedEventHandler <AccountsSettingsPane, AccountsSettingsPaneCommandsRequestedEventArgs> AccountCommandsRequestedHandler = null;
AccountCommandsRequestedHandler = async(s, e) =>
{
Debug.WriteLine("AccountCommandsRequestedHandler");
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested -= AccountCommandsRequestedHandler;
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
if (deferral != null)
{
// The Microsoft account provider is always present in Windows 10 devices, even IoT Core, as is the Azure AD plugin.
var providerCommand = new WebAccountProviderCommand(await GetProvider(), async(command) =>
{
Debug.WriteLine("WebAccountProviderCommandInvokedHandler");
try
{
WebTokenRequest wtr = new WebTokenRequest(command.WebAccountProvider, _scope, _clientId);
if (resource != null)
{
wtr.Properties.Add("resource", resource);
}
var wtrr = await RequestTokenWithTimeout(wtr);
SaveToken(wtrr, resource);
taskCompletionSource.SetResult(wtrr);
}
catch (Exception ex)
{
ServiceUtil.LogService.Write("Web Token Request Error: " + ex.Message, LoggingLevel.Error);
taskCompletionSource.SetResult(null);
}
});
e.WebAccountProviderCommands.Add(providerCommand);
deferral.Complete();
}
};
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += AccountCommandsRequestedHandler;
await AccountsSettingsPane.ShowAddAccountAsync();
return(await taskCompletionSource.Task);
}
private async void BuildAccountsSettingsPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
s.AccountCommandsRequested -= BuildAccountsSettingsPaneAsync;
var deferral = e.GetDeferral();
e.HeaderText = resourceService.GetString("SignInDescription");
var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", "consumers");
var command = new WebAccountProviderCommand(msaProvider, GetMsaToken);
e.WebAccountProviderCommands.Add(command);
deferral.Complete();
}
private async void OnAccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
try
{
foreach (var pi in _providers)
{
// This scenario only lets the user have one account at a time.
// If there already is an account, we do not include a provider in the list
// This will prevent the add account button from showing up.
if (this.HasWebAccountInfo(pi.WebAccountType))
{
WebAccount account = await this.GetWebAccount(pi.WebAccountType);
if (account != null)
{
WebAccountCommand command = new WebAccountCommand(account, OnWebAccountRequested, pi.Actions);
e.WebAccountCommands.Add(command);
}
}
else
{
var provider = await this.GetProvider(pi.ProviderID, pi.Authority);
if (provider != null)
{
WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, OnWebAccountProviderRequested);
e.WebAccountProviderCommands.Add(providerCommand);
}
}
}
e.HeaderText = string.Format(Strings.Account.TextWebAccountManagerSignUpDescription, PlatformBase.CurrentCore.AppInfo.AppName);
// You can add links such as privacy policy, help, general account settings
e.Commands.Add(new SettingsCommand("privacypolicy", Strings.Resources.ViewTitlePrivacyPolicy, (c) => { PlatformBase.CurrentCore.NavigationBase.PrivacyPolicyCommand.Execute(null); this.Cleanup(); }));
e.Commands.Add(new SettingsCommand("tos", Strings.Resources.ViewTitleTermsOfService, (c) => { PlatformBase.CurrentCore.NavigationBase.TermsOfServiceCommand.Execute(null); this.Cleanup(); }));
}
catch (Exception ex)
{
PlatformBase.CurrentCore.Logger.LogError(ex, "Failed to display the web account manager UI.");
throw ex;
}
finally
{
deferral.Complete();
}
}
private void MainPage_AccountCommandsRequested(AccountsSettingsPane sender,
AccountsSettingsPaneCommandsRequestedEventArgs args)
{
var credDeletedHandler = new CredentialCommandCredentialDeletedHandler(h => AccountsSettingsPane.Show());
var vault = new PasswordVault();
var creds = vault.RetrieveAll();
foreach (PasswordCredential c in creds)
{
var credCommand1 = new CredentialCommand(c, credDeletedHandler);
args.CredentialCommands.Add(credCommand1);
}
}
public static AccountsSettingsPane GetForWindow(IntPtr hWnd)
{
IAccountsSettingsPaneInterop accountsSettingsPaneInterop =
AccountsSettingsPane.As <IAccountsSettingsPaneInterop>();
//Guid guid = typeof(AccountsSettingsPane).GUID;
Guid guid = //WinRT.GuidGenerator.CreateIID(typeof(IAccountsSettingPane));
Guid.Parse("81EA942C-4F09-4406-A538-838D9B14B7E6");
//IAccountsSettingsPaneInterop accountsSettingsPaneInterop =
// (IAccountsSettingsPaneInterop)WindowsRuntimeMarshal.GetActivationFactory(typeof(AccountsSettingsPane));
//Guid guid = typeof(AccountsSettingsPane).GetInterface("IAccountsSettingsPane").GUID;
accountsSettingsPaneInterop.GetForWindow(hWnd, ref guid, out IntPtr result);
return(MarshalInterface <AccountsSettingsPane> .FromAbi(result));
}
private async void BuildAccountsSettingsPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
s.AccountCommandsRequested -= BuildAccountsSettingsPaneAsync;
var deferral = e.GetDeferral();
e.HeaderText = resourceService.GetString("SignInDescription");
var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", "consumers");
var command = new WebAccountProviderCommand(msaProvider, GetMsaToken);
e.WebAccountProviderCommands.Add(command);
deferral.Complete();
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += MainPage_AccountCommandsRequested;
await DocumentManager.LoadAccountAsync();
if (DocumentManager.Account != null)
{
await DocumentManager.LoadItemsAsync();
}
else
{
AccountsSettingsPane.Show();
}
}
private async void SignInButton_Click(object sender, RoutedEventArgs e)
{
((Button)sender).IsEnabled = false;
if (_userAccountManager.UserIsSignedIn)
{
await _userAccountManager.SignOutAccountAsync();
}
else
{
AccountsSettingsPane.Show();
}
((Button)sender).IsEnabled = true;
}
private async void PlaylistsButton_OnClick(object sender, RoutedEventArgs e)
{
((Button)sender).IsEnabled = false;
if (_userAccountManager.UserIsSignedIn)
{
await MusicContentPaneViewModel.GetPlaylistsAsync();
}
else
{
AccountsSettingsPane.Show();
}
((Button)sender).IsEnabled = true;
}
private async void Session_Click(object sender, RoutedEventArgs e)
{
string silentToken = await GetMsaTokenSilentlyAsync();
if (silentToken != null)
{
OdManager.Token = silentToken;
this.Frame.Navigate(typeof(AnnotatedAudio.View.SessionPicker), OdManager);
}
else
{
Debug.WriteLine("accountsettingspane show");
AccountsSettingsPane.Show();
}
}
public Scenario2()
{
this.InitializeComponent();
try
{
// SettingsPane is the existing Win8 API for the Settings Contract
SettingsPane.GetForCurrentView().CommandsRequested += MainPage_CommandsRequested;
//Adding AccountControl callback
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += MainPage_AccountCommandsRequested;
}
catch (Exception Error) // No stored credentials, so none to delete
{
DebugPrint(Error.Message);
}
}
void CredentialDeletedHandler(CredentialCommand sender)
{
try
{
// callback invoked when the user requests deletion of the credential in the accounts flyout
// System will invoke this callback after successfully deleting the credential from the vault
// do post delete work
// show accounts settings pane to reflect the new state
AccountsSettingsPane.Show();
DebugPrint("Your credential is removed from PasswordVault");
}
catch (Exception Error) // No stored credentials, so none to delete
{
DebugPrint(Error.Message);
}
}
/// <summary>
/// This method customizes the accounts settings pane to setup user authentication with Microsoft accounts.
/// You need to register this method to the AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested event.
/// Don't forget to also remove the event handler (for example when user navigates away from your page).
/// </summary>
public async void BuildAccountPaneAsync(
AccountsSettingsPane s,
AccountsSettingsPaneCommandsRequestedEventArgs e)
{
var deferral = e.GetDeferral();
var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
MicrosoftAccountProviderId,
ConsumerAuthority);
var command = new WebAccountProviderCommand(msaProvider, SignInUserAccountAsync);
e.WebAccountProviderCommands.Add(command);
deferral.Complete();
}
public void AccountCommandsRequested(AccountsSettingsPane accountsSettingsPane, AccountsSettingsPaneCommandsRequestedEventArgs eventArgs)
{
var deferral = eventArgs.GetDeferral();
ResourceLoader _res = ResourceLoader.GetForCurrentView();
eventArgs.HeaderText = _res.GetString("LoginDescription");
eventArgs.WebAccountProviderCommands.Clear();
eventArgs.WebAccountCommands.Clear();
#if STEP2
WebAccountProviderCommand googlePlusProviderCommand = new WebAccountProviderCommand(_app.SynchroManager.GetProvider(SynchroManager.ServerName.GooglePlus), WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(googlePlusProviderCommand);
WebAccountProviderCommand facebookProviderCommand = new WebAccountProviderCommand(_app.SynchroManager.GetProvider(SynchroManager.ServerName.Facebook), WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(facebookProviderCommand);
#endif
WebAccountProviderCommand dropboxProviderCommand = new WebAccountProviderCommand(_app.SynchroManager.GetProvider(SynchroManager.ServerName.Dropbox), WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(dropboxProviderCommand);
WebAccountProviderCommand usbProviderCommand = new WebAccountProviderCommand(_app.SynchroManager.GetProvider(SynchroManager.ServerName.Usb), WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(usbProviderCommand);
#if STEP2
if (_app.SynchroManager.LoggedIn(SynchroManager.ServerName.Facebook))
{
eventArgs.WebAccountCommands.Add(_app.SynchroManager.GetAccount(SynchroManager.ServerName.Facebook));
}
if (_app.SynchroManager.LoggedIn(SynchroManager.ServerName.GooglePlus))
{
eventArgs.WebAccountCommands.Add(_app.SynchroManager.GetAccount(SynchroManager.ServerName.GooglePlus));
}
#endif
if (_app.SynchroManager.LoggedIn(SynchroManager.ServerName.Dropbox))
{
eventArgs.WebAccountCommands.Add(_app.SynchroManager.GetAccount(SynchroManager.ServerName.Dropbox));
}
if (_app.SynchroManager.LoggedIn(SynchroManager.ServerName.Usb))
{
eventArgs.WebAccountCommands.Add(_app.SynchroManager.GetAccount(SynchroManager.ServerName.Usb));
}
deferral.Complete();
}
private async void Initalise()
{
await Shared.Services.Storage.InitaliseAsync();
LoadingHeader.Text = "Nearly finished..";
await Shared.Services.Storage.SyncAsync();
await App.HomesViewModel.Initalise();
if (App.HomesViewModel.Homes.Count() == 0)
{
App.HomesViewModel.HomeName = "My Home";
App.HomesViewModel.UserName = user.AccountName;
App.HomesViewModel.AddHomeCommand.Execute(null);
}
try
{
App.RoomsViewModel.SelectedHomeId = App.HomesViewModel.SelectedHome.Id;
}
catch (Exception ex)
{
Debug.WriteLine("ActivationService.Initalise - Error loading rooms: " + ex.Message);
}
AppShell shell = Window.Current.Content as AppShell;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (shell == null)
{
// Create a AppShell to act as the navigation context and navigate to the first page
shell = new AppShell();
}
// Place our app shell in the current Window
Window.Current.Content = shell;
if (shell.AppFrame.Content == null)
{
AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested -= OnAccountCommandsRequested;
shell.AppFrame.Navigate(typeof(Views.Overview.MainPage));
}
Window.Current.Activate();
}
private async void OnAccountCommandsRequested(
AccountsSettingsPane sender,
AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
// This scenario only supports a single account at one time.
// If there already is an account, we do not include a provider in the list
// This will prevent the add account button from showing up.
await AddWebAccountProvidersToPane(e);
await AddWebAccountsToPane(e);
AddLinksAndDescription(e);
deferral.Complete();
}
public static IAsyncAction ShowAddAccountForWindowAsync(IntPtr hWnd)
{
IWebAuthenticationCoreManagerInterop webAuthenticationCoreManagerInterop =
WebAuthenticationCoreManager.As <IWebAuthenticationCoreManagerInterop>();
IAccountsSettingsPaneInterop accountsSettingsPaneInterop =
AccountsSettingsPane.As <IAccountsSettingsPaneInterop>();
//Guid guid = typeof(IAsyncAction).GUID;
Guid guid = WinRT.GuidGenerator.CreateIID(typeof(IAsyncAction));
//IAccountsSettingsPaneInterop accountsSettingsPaneInterop =
// (IAccountsSettingsPaneInterop)WindowsRuntimeMarshal.GetActivationFactory(typeof(AccountsSettingsPane));
//Guid guid = typeof(IAsyncAction).GUID;
accountsSettingsPaneInterop.ShowAddAccountForWindowAsync(hWnd, ref guid, out IntPtr result);
return(MarshalInterface <IAsyncAction> .FromAbi(result));
}
private async void OnAccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
try
{
foreach (var pi in _providers)
{
// This scenario only lets the user have one account at a time.
// If there already is an account, we do not include a provider in the list
// This will prevent the add account button from showing up.
if (this.HasWebAccountInfo(pi.WebAccountType))
{
WebAccount account = await this.GetWebAccount(pi.WebAccountType);
if (account != null)
{
WebAccountCommand command = new WebAccountCommand(account, OnWebAccountRequested, pi.Actions);
e.WebAccountCommands.Add(command);
}
}
else
{
var provider = await this.GetProvider(pi.ProviderID, pi.Authority);
if (provider != null)
{
WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, OnWebAccountProviderRequested);
e.WebAccountProviderCommands.Add(providerCommand);
}
}
}
e.HeaderText = Strings.Account.TextWebAccountManagerSignUpDescription;
// You can add links such as privacy policy, help, general account settings
e.Commands.Add(new SettingsCommand("privacypolicy", Strings.Resources.ViewTitlePrivacyPolicy, (c) => { Platform.Current.Navigation.NavigateToPrivacyPolicyCommand.Execute(null); this.Cleanup(); }));
e.Commands.Add(new SettingsCommand("tos", Strings.Resources.ViewTitleTermsOfService, (c) => { Platform.Current.Navigation.NavigateToTermsOfServiceCommand.Execute(null); this.Cleanup(); }));
}
catch(Exception ex)
{
Platform.Current.Logger.LogError(ex, "Failed to display the web account manager UI.");
throw ex;
}
finally
{
deferral.Complete();
}
}
public AccountsSettingsPaneEvents(AccountsSettingsPane This)
{
this.This = This;
}
private static async void OnAccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
var deferral = e.GetDeferral();
// The Microsoft account provider is always present in Windows 10 devices, as is the Azure AD plugin.
// If a non-installed plugin or incorect identity is specified, FindAccountProviderAsync will return null
var webAccountProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
AccountProviderId, Authority);
var providerCommand = new WebAccountProviderCommand(webAccountProvider,
async (c) =>
{
try
{
currentToken = await GetTokenHelperAsync(c.WebAccountProvider, GraphResourceId);
DiscoveryClient discoveryClient = new DiscoveryClient(
async () => await GetTokenHelperAsync(null, DiscoveryResourceId));
//Get capabilities
capabilities = await discoveryClient.DiscoverCapabilitiesAsync() as Dictionary<string, CapabilityDiscoveryResult>;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
SignOutAsync().Wait();
tcs.TrySetResult(false);
}
var isValid = !String.IsNullOrEmpty(currentToken);
if (!isValid)
await SignOutAsync();
tcs.TrySetResult(isValid);
});
e.WebAccountProviderCommands.Add(providerCommand);
deferral.Complete();
}
public async void AccountCommandsRequested(AccountsSettingsPane accountsSettingsPane, AccountsSettingsPaneCommandsRequestedEventArgs eventArgs)
{
AccountsSettingsPaneEventDeferral deferral = eventArgs.GetDeferral();
HttpResult<ManageInfo> result;
using (AccountClient accountClient = ClientFactory.CreateAccountClient())
{
result = await accountClient.GetManageInfoAsync();
}
if (!result.Succeeded)
{
await ErrorDialog.ShowErrorsAsync(result.Errors);
// The log off command is not available on the account settings page if there are no accounts, so log off now
LogOff();
deferral.Complete();
return;
}
ManageInfo manageInfo = result.Content;
this.username = manageInfo.UserName;
this.localProvider = manageInfo.LocalLoginProvider;
eventArgs.HeaderText = "Manage your account logins";
////Add WebAccountProviders
Dictionary<string, WebAccountProvider> webProviders = new Dictionary<string, WebAccountProvider>();
WebAccountProviderCommandInvokedHandler providerCommandHandler = new WebAccountProviderCommandInvokedHandler(WebAccountProviderInvokedHandler);
foreach (ExternalLogin externalLogin in manageInfo.ExternalLoginProviders)
{
WebAccountProvider provider = new WebAccountProvider(externalLogin.Url, externalLogin.Name, App.LoginIcons[externalLogin.Name]);
WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, providerCommandHandler);
eventArgs.WebAccountProviderCommands.Add(providerCommand);
webProviders[provider.DisplayName] = provider;
}
WebAccountProvider localLoginProvider = new WebAccountProvider(manageInfo.LocalLoginProvider, manageInfo.LocalLoginProvider, null);
webProviders[manageInfo.LocalLoginProvider] = localLoginProvider;
////Add WebAccounts and local accounts if available.
bool hasLocalLogin = false;
foreach (UserLoginInfo userLoginInfo in manageInfo.Logins)
{
WebAccountCommandInvokedHandler accountCommandHandler;
SupportedWebAccountActions supportedActions = SupportedWebAccountActions.None;
if (manageInfo.Logins.Length > 1)
{
supportedActions |= SupportedWebAccountActions.Remove;
}
if (userLoginInfo.LoginProvider == manageInfo.LocalLoginProvider)
{
hasLocalLogin = true;
supportedActions |= SupportedWebAccountActions.Manage;
accountCommandHandler = new WebAccountCommandInvokedHandler(LocalWebAccountInvokedHandler);
}
else
{
accountCommandHandler = new WebAccountCommandInvokedHandler(WebAccountInvokedHandler);
}
WebAccount webAccount = new WebAccount(webProviders[userLoginInfo.LoginProvider], userLoginInfo.ProviderKey, WebAccountState.Connected);
WebAccountCommand webAccountCommand = new WebAccountCommand(webAccount, accountCommandHandler, supportedActions);
eventArgs.WebAccountCommands.Add(webAccountCommand);
}
if (!hasLocalLogin)
{
WebAccountProviderCommandInvokedHandler localProviderCmdHandler = new WebAccountProviderCommandInvokedHandler(LocalProviderInvokedHandler);
WebAccountProviderCommand localProviderCommand = new WebAccountProviderCommand(localLoginProvider, localProviderCmdHandler);
eventArgs.WebAccountProviderCommands.Add(localProviderCommand);
}
SettingsCommand logOffCommand = new SettingsCommand("Logoff", "Log off", new UICommandInvokedHandler(LogOffHandler));
eventArgs.Commands.Add(logOffCommand);
deferral.Complete();
}
/// <summary>
/// This event is generated when the user clicks on Accounts command in settings pane. During this event, add your
/// WebAccountProviderCommand, WebAccountCommand, CredentialCommand and SettingsCommand objects to make them available to the
/// AccountsSettingsPane UI.
/// </summary>
/// <param name="accountsSettingsPane">Instance that triggered the event.</param>
/// <param name="eventArgs">Event data describing the conditions that led to the event.</param>
private void AccountCommandsRequested(AccountsSettingsPane accountsSettingsPane, AccountsSettingsPaneCommandsRequestedEventArgs eventArgs)
{
var deferral = eventArgs.GetDeferral();
//Add header text.
eventArgs.HeaderText = "This is sample text. You can put a message here to give context to user. This section is optional.";
//Add WebAccountProviders
WebAccountProviderCommandInvokedHandler providerCmdHandler = new WebAccountProviderCommandInvokedHandler(WebAccountProviderInvokedHandler);
WebAccountProviderCommand facebookProviderCommand = new WebAccountProviderCommand(facebookProvider, WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(facebookProviderCommand);
WebAccountProviderCommand twitterProviderCommand = new WebAccountProviderCommand(twitterProvider, WebAccountProviderInvokedHandler);
eventArgs.WebAccountProviderCommands.Add(twitterProviderCommand);
//Add WebAccounts if available.
WebAccountCommandInvokedHandler accountCmdHandler = new WebAccountCommandInvokedHandler(WebAccountInvokedHandler);
if (isFacebookUserLoggedIn)
{
facebookAccount = new WebAccount(facebookProvider, facebookUserName, WebAccountState.Connected);
WebAccountCommand facebookAccountCommand = new WebAccountCommand(
facebookAccount, WebAccountInvokedHandler,
SupportedWebAccountActions.Remove | SupportedWebAccountActions.Manage);
eventArgs.WebAccountCommands.Add(facebookAccountCommand);
}
if (isTwitterUserLoggedIn)
{
twitterAccount = new WebAccount(twitterProvider, twitterUserName, WebAccountState.Connected);
WebAccountCommand twitterAccountCommand = new WebAccountCommand(
twitterAccount, WebAccountInvokedHandler,
SupportedWebAccountActions.Remove | SupportedWebAccountActions.Manage);
eventArgs.WebAccountCommands.Add(twitterAccountCommand);
}
// Add links if needed.
Object commandID = 1;
UICommandInvokedHandler globalLinkInvokedHandler = new UICommandInvokedHandler(GlobalLinkInvokedhandler);
SettingsCommand command = new SettingsCommand(
commandID,
"More details",
globalLinkInvokedHandler);
eventArgs.Commands.Add(command);
SettingsCommand command1 = new SettingsCommand(
commandID,
"Privacy policy",
globalLinkInvokedHandler);
eventArgs.Commands.Add(command1);
deferral.Complete();
}
private async void AccountCommandsRequested(AccountsSettingsPane accountsSettingsPane, AccountsSettingsPaneCommandsRequestedEventArgs eventArgs)
{
AccountsSettingsPaneEventDeferral deferral = eventArgs.GetDeferral();
HttpResult<ExternalLogin[]> result;
using (AccountClient accountClient = ClientFactory.CreateAccountClient())
{
result = await accountClient.GetExternalLoginsAsync();
}
if (result.Succeeded)
{
eventArgs.HeaderText = "Please select a login provider.";
WebAccountProviderCommandInvokedHandler providerCmdHandler = new WebAccountProviderCommandInvokedHandler(WebAccountProviderInvokedHandler);
foreach (ExternalLogin externalLogin in result.Content)
{
WebAccountProvider provider = new WebAccountProvider(externalLogin.Url, externalLogin.Name, App.LoginIcons[externalLogin.Name]);
WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, providerCmdHandler);
eventArgs.WebAccountProviderCommands.Add(providerCommand);
}
}
else
{
await ErrorDialog.ShowErrorsAsync("Error connecting to external accounts.", result.Errors);
}
deferral.Complete();
}
private async void OnAccountCommandsRequested(
AccountsSettingsPane sender,
AccountsSettingsPaneCommandsRequestedEventArgs e)
{
// In order to make async calls within this callback, the deferral object is needed
AccountsSettingsPaneEventDeferral deferral = e.GetDeferral();
// This scenario only supports a single account at one time.
// If there already is an account, we do not include a provider in the list
// This will prevent the add account button from showing up.
await AddWebAccountProvidersToPane(e);
await AddWebAccountsToPane(e);
AddLinksAndDescription(e);
deferral.Complete();
}
