public void TestExecute()
{
WebRequestFactory.Current = new TestWebRequestFactory();
#if NETFX_CORE
LiveAuthClient authClient = new LiveAuthClient();
#elif WINDOWS_PHONE
LiveAuthClient authClient = new LiveAuthClient("clientId");
#else
#error This platform needs to be handled.
#endif
string clientId = "clientId";
string refreshToken = "refreshToken";
IEnumerable<string> scopes = new string[]{ "wl.basic" };
SynchronizationContextWrapper syncContext = SynchronizationContextWrapper.Current;
var refreshOperation =
new RefreshTokenOperation(authClient, clientId, refreshToken, scopes, syncContext);
}
/// <summary>
/// Processes authentication result from the server.
/// Method could return synchronously or asynchronously.
/// </summary>
private void ProcessAuthResponse(string responseData, Action<LiveLoginResult> callback)
{
if (string.IsNullOrEmpty(responseData))
{
// non-connected user scenario. return status unknown.
callback(new LiveLoginResult(LiveConnectSessionStatus.Unknown, null));
return;
}
Uri responseUrl;
try
{
responseUrl = new Uri(responseData, UriKind.Absolute);
}
catch (FormatException)
{
callback(new LiveLoginResult(
new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"))));
return;
}
if (!string.IsNullOrEmpty(responseUrl.Fragment))
{
callback(this.ParseResponseFragment(responseUrl.Fragment));
return;
}
if (!string.IsNullOrEmpty(responseUrl.Query))
{
IDictionary<string, object> parameters = LiveAuthClient.ParseQueryString(responseUrl.Query);
if (parameters.ContainsKey(AuthConstants.Code))
{
var authCode = parameters[AuthConstants.Code] as string;
if (!string.IsNullOrEmpty(authCode))
{
var refreshOp = new RefreshTokenOperation(
this,
this.clientId,
authCode,
this.redirectUri,
this.syncContext);
refreshOp.OperationCompletedCallback = callback;
refreshOp.Execute();
return;
}
}
else if (parameters.ContainsKey(AuthConstants.Error))
{
callback(GetErrorResult(parameters));
return;
}
}
callback(
new LiveLoginResult(
new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"))));
}
internal Task<LiveLoginResult> RefreshTokenAsync()
{
var refreshOp = new RefreshTokenOperation(
this,
this.clientId,
this.Session.RefreshToken,
this.Session.Scopes,
null);
return refreshOp.ExecuteAsync();
}
/// <summary>
/// Initializes the auth client. Detects if user is already signed in,
/// If user is already signed in, creates a valid Session.
/// This call is UI-less.
/// </summary>
/// <param name="scopes">The list of offers that the application is requesting user consent for.</param>
/// <returns>A Task object representing the asynchronous operation.</returns>
public async Task<LiveLoginResult> InitializeAsync(IEnumerable<string> scopes)
{
this.PrepareForAsync();
// Always make a call to the server instead of relying on cached access token for two reasons:
// 1. user may have revoked the scope
// 2. user may have previously consented to the scope via a web app, we should not ask again.
// Use a refresh token if present, if not, use silent flow.
LiveConnectSession currentSession = this.AuthClient.LoadSession(this);
this.scopes = (scopes == null) ? new List<string>() : new List<string>(scopes);
bool hasRefreshToken = currentSession != null && !string.IsNullOrEmpty(currentSession.RefreshToken);
if (hasRefreshToken)
{
var refreshOp = new RefreshTokenOperation(
this,
this.clientId,
currentSession.RefreshToken,
this.scopes,
null);
var tcs = new TaskCompletionSource<LiveLoginResult>();
try
{
LiveLoginResult refreshOpResult = await refreshOp.ExecuteAsync();
this.Session = refreshOpResult.Session;
this.AuthClient.SaveSession(this.Session);
tcs.TrySetResult(refreshOpResult);
}
catch (Exception exception)
{
this.Session = null;
tcs.TrySetException(exception);
}
finally
{
Interlocked.Decrement(ref this.asyncInProgress);
}
return await tcs.Task;
}
// If we do NOT have a refresh token, use the silent flow.
return await this.AuthenticateAsync(true /* silent flow */);
}
/// <summary>
/// Retrieve a new access token based on current session information.
/// </summary>
internal bool RefreshToken(Action<LiveLoginResult> completionCallback)
{
if (this.Session == null || this.Session.IsValid)
{
return false;
}
var refreshOp = new RefreshTokenOperation(
this,
this.clientId,
this.Session.RefreshToken,
this.Session.Scopes,
null)
{
OperationCompletedCallback = completionCallback
};
refreshOp.Execute();
return true;
}
