Google Calendar API for UWP Windows 10 Application One or more errors occurred

Question

I\'m trying to use Google Calendar API v3, but i have problems while running the codes, it always gives me that error :

An exception of type \'System

Answer 1

I have the Google .NET Client working in my UWP app. The trick is that you have to put it in a .NET Standard 2.0 Class Library, expose the API services you need, and then reference that library from your UWP app.

Also, you have to handle the getting the auth token yourself. It's not that much work and the Drive APIs and Calendar APIs work just fine (the only ones I've tried). You can see that I pass in a simple class that contains the auth token and other auth details to a method called Initialize.

Here is the single class I used in the .NET Standard 2.0 class library:

namespace GoogleProxy
{
public class GoogleService
{
    public CalendarService calendarService { get; private set; }

    public DriveService driveService { get; private set; }


    public GoogleService()
    {

    }

    public void Initialize(AuthResult authResult)
    {
        var credential = GetCredentialForApi(authResult);
        var baseInitializer = new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = "{your app name here}" };

        calendarService = new Google.Apis.Calendar.v3.CalendarService(baseInitializer);
        driveService = new Google.Apis.Drive.v3.DriveService(baseInitializer);
    }

    private UserCredential GetCredentialForApi(AuthResult authResult)
    {
        var initializer = new GoogleAuthorizationCodeFlow.Initializer
        {
            ClientSecrets = new ClientSecrets
            {
                ClientId = "{your app client id here}",
                ClientSecret = "",
            },
            Scopes = new string[] { "openid", "email", "profile",  "https://www.googleapis.com/auth/calendar.readonly", "https://www.googleapis.com/auth/calendar.events.readonly", "https://www.googleapis.com/auth/drive.readonly" },
        };

        var flow = new GoogleAuthorizationCodeFlow(initializer);

        var token = new TokenResponse()
        {
            AccessToken = authResult.AccessToken,
            RefreshToken = authResult.RefreshToken,
            ExpiresInSeconds = authResult.ExpirationInSeconds,
            IdToken = authResult.IdToken,
            IssuedUtc = authResult.IssueDateTime,
            Scope = "openid email profile https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/calendar.events.readonly https://www.googleapis.com/auth/drive.readonly",
            TokenType = "bearer" };

        return new UserCredential(flow, authResult.Id, token);
    }

}
}

In order to get the Auth token from google, you have to use custom schemes. Register your app as an 'iOS' app on the google services console and put in a URI scheme (something unique). Then add this scheme to your UWP manifest under Declarations->Protocol. Handle it in your App.xaml.cs:

protected override void OnActivated(IActivatedEventArgs args)
    {
        base.OnActivated(args);
        if (args.Kind == ActivationKind.Protocol)
        {
            ProtocolActivatedEventArgs protocolArgs = (ProtocolActivatedEventArgs)args;
            Uri uri = protocolArgs.Uri;
            Debug.WriteLine("Authorization Response: " + uri.AbsoluteUri);
            locator.AccountsService.GoogleExternalAuthWait.Set(uri.Query);
        }
    }

That GoogleExternalAuthWait comes from some magical code I found about how to create an asynchronous ManualResetEvent. https://blogs.msdn.microsoft.com/pfxteam/2012/02/11/building-async-coordination-primitives-part-1-asyncmanualresetevent/ It looks like this (I only converted it to generic).

    public class AsyncManualResetEvent
{
    private volatile TaskCompletionSource m_tcs = new TaskCompletionSource();

    public Task WaitAsync() { return m_tcs.Task; }

    public void Set(T TResult) { m_tcs.TrySetResult(TResult); }

    public bool IsReset => !m_tcs.Task.IsCompleted;

    public void Reset()
    {
        while (true)
        {
            var tcs = m_tcs;
            if (!tcs.Task.IsCompleted ||
                Interlocked.CompareExchange(ref m_tcs, new TaskCompletionSource(), tcs) == tcs)
                return;
        }
    }
}

This is how you start the Google Authorization. What happens is it launches an external browser to begin the google signing process and then wait (that's what the AsyncManualResetEvent does). When you're done, Google will launch a URI using your custom scheme. You should get a message dialog saying the browser is trying to open an app... click ok and the AsyncManualResetEvent continues and finishes the auth process. You'll need to make a class that contains all the auth info to pass to your class library.

private async Task AuthenticateGoogleAsync()
    {
        try
        {
            var stateGuid = Guid.NewGuid().ToString();
            var expiration = DateTimeOffset.Now;
            var url = $"{GoogleAuthorizationEndpoint}?client_id={WebUtility.UrlEncode(GoogleAccountClientId)}&redirect_uri={WebUtility.UrlEncode(GoogleRedirectURI)}&state={stateGuid}&scope={WebUtility.UrlEncode(GoogleScopes)}&display=popup&response_type=code";

            var success = Windows.System.Launcher.LaunchUriAsync(new Uri(url));

            GoogleExternalAuthWait = new AsyncManualResetEvent();

            var query = await GoogleExternalAuthWait.WaitAsync();

            var dictionary = query.Substring(1).Split('&').ToDictionary(x => x.Split('=')[0], x => Uri.UnescapeDataString(x.Split('=')[1]));
            if (dictionary.ContainsKey("error"))
            {
                return null;
            }
            if (!dictionary.ContainsKey("code") || !dictionary.ContainsKey("state"))
            {
                return null;
            }
            if (dictionary["state"] != stateGuid)
                return null;

            string tokenRequestBody = $"code={dictionary["code"]}&redirect_uri={Uri.EscapeDataString(GoogleRedirectURI)}&client_id={GoogleAccountClientId}&access_type=offline&scope=&grant_type=authorization_code";

            StringContent content = new StringContent(tokenRequestBody, Encoding.UTF8, "application/x-www-form-urlencoded");


            // Performs the authorization code exchange.
            using (HttpClientHandler handler = new HttpClientHandler())
            {
                handler.AllowAutoRedirect = true;
                using (HttpClient client = new HttpClient(handler))
                {
                    HttpResponseMessage response = await client.PostAsync(GoogleTokenEndpoint, content);
                    if (response.IsSuccessStatusCode)
                    {

                        var stringResponse = await response.Content.ReadAsStringAsync();
                        var json = JObject.Parse(stringResponse);
                        var id = DecodeIdFromJWT((string)json["id_token"]);
                        var oauthToken = new AuthResult()
                        {
                            Provider = AccountType.Google,
                            AccessToken = (string)json["access_token"],
                            Expiration = DateTimeOffset.Now + TimeSpan.FromSeconds(int.Parse((string)json["expires_in"])),
                            Id = id,
                            IdToken = (string)json["id_token"],
                            ExpirationInSeconds = long.Parse((string)json["expires_in"]),
                            IssueDateTime = DateTime.Now,
                            RefreshToken = (string)json["refresh_token"]
                        };
                        return oauthToken;
                    }
                    else
                    {
                        return null;
                    }

                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
            return null;
        }
    }