Activated contact service for Gmail to retrieve profile picture and sender name.

Wino.Core/Synchronizers/BaseSynchronizer.cs

@@ -3,6 +3,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.Messaging;
@@ -69,8 +70,42 @@ namespace Wino.Core.Synchronizers
         /// <param name="cancellationToken">Cancellation token</param>
         public abstract Task ExecuteNativeRequestsAsync(IEnumerable<IRequestBundle<TBaseRequest>> batchedRequests, CancellationToken cancellationToken = default);
 
-        public abstract Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Refreshed remote mail account profile if possible.
+        /// Aliases, profile pictures, mailbox settings will be handled in this step.
+        /// </summary>
+        protected virtual Task SynchronizeProfileInformationAsync() => Task.CompletedTask;
 
+        /// <summary>
+        /// Returns the base64 encoded profile picture of the account from the given URL.
+        /// </summary>
+        /// <param name="url">URL to retrieve picture from.</param>
+        /// <returns>base64 encoded profile picture</returns>
+        protected async Task<string> GetProfilePictureBase64EncodedAsync(string url)
+        {
+            using var client = new HttpClient();
+
+            var response = await client.GetAsync(url).ConfigureAwait(false);
+            var byteContent = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+
+            return Convert.ToBase64String(byteContent);
+        }
+
+        /// <summary>
+        /// Internally synchronizes the account with the given options.
+        /// Not exposed and overriden for each synchronizer.
+        /// </summary>
+        /// <param name="options">Synchronization options.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>Synchronization result that contains summary of the sync.</returns>
+        protected abstract Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Batches network requests, executes them, and does the needed synchronization after the batch request execution.
+        /// </summary>
+        /// <param name="options">Synchronization options.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>Synchronization result that contains summary of the sync.</returns>
         public async Task<SynchronizationResult> SynchronizeAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
             try
@@ -104,6 +139,14 @@ namespace Wino.Core.Synchronizers
 
                 await synchronizationSemaphore.WaitAsync(activeSynchronizationCancellationToken);
 
+                if (options.Type == SynchronizationType.Full)
+                {
+                    // Refresh profile information and mailbox settings on full synchronization.
+                    // Exceptions here is not critical. Therefore, they are ignored.
+
+                    await SynchronizeProfileInformationAsync();
+                }
+
                 // Let servers to finish their job. Sometimes the servers doesn't respond immediately.
 
                 bool shouldDelayExecution = batches.Any(a => a.DelayExecution);
@@ -150,6 +193,10 @@ namespace Wino.Core.Synchronizers
         private void PublishUnreadItemChanges()
             => WeakReferenceMessenger.Default.Send(new RefreshUnreadCountsMessage(Account.Id));
 
+        /// <summary>
+        /// Sends a message to the shell to update the synchronization progress.
+        /// </summary>
+        /// <param name="progress">Percentage of the progress.</param>
         public void PublishSynchronizationProgress(double progress)
             => WeakReferenceMessenger.Default.Send(new AccountSynchronizationProgressUpdatedMessage(Account.Id, progress));
 

Wino.Core/Synchronizers/GmailSynchronizer.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using Google.Apis.Gmail.v1;
 using Google.Apis.Gmail.v1.Data;
 using Google.Apis.Http;
+using Google.Apis.PeopleService.v1;
 using Google.Apis.Requests;
 using Google.Apis.Services;
 using MailKit;
@@ -37,8 +38,10 @@ namespace Wino.Core.Synchronizers
         // https://github.com/googleapis/google-api-dotnet-client/issues/2603
         private const uint MaximumAllowedBatchRequestSize = 10;
 
-        private readonly ConfigurableHttpClient _gmailHttpClient;
+        private readonly ConfigurableHttpClient _googleHttpClient;
         private readonly GmailService _gmailService;
+        private readonly PeopleServiceService _peopleService;
+
         private readonly IAuthenticator _authenticator;
         private readonly IGmailChangeProcessor _gmailChangeProcessor;
         private readonly ILogger _logger = Log.ForContext<GmailSynchronizer>();
@@ -54,15 +57,64 @@ namespace Wino.Core.Synchronizers
                 HttpClientFactory = this
             };
 
-            _gmailHttpClient = new ConfigurableHttpClient(messageHandler);
+            _googleHttpClient = new ConfigurableHttpClient(messageHandler);
+
             _gmailService = new GmailService(initializer);
+            _peopleService = new PeopleServiceService(initializer);
+
             _authenticator = authenticator;
             _gmailChangeProcessor = gmailChangeProcessor;
         }
 
-        public ConfigurableHttpClient CreateHttpClient(CreateHttpClientArgs args) => _gmailHttpClient;
+        public ConfigurableHttpClient CreateHttpClient(CreateHttpClientArgs args) => _googleHttpClient;
 
-        public override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
+        protected override async Task SynchronizeProfileInformationAsync()
+        {
+            // Gmail profile info synchronizes Alias and Profile Picture.
+
+            try
+            {
+                var profileRequest = _peopleService.People.Get("people/me");
+                profileRequest.PersonFields = "names,photos";
+
+                string senderName = Account.SenderName, base64ProfilePicture = Account.ProfilePictureBase64;
+
+                var userProfile = await profileRequest.ExecuteAsync();
+
+                senderName = userProfile.Names?.FirstOrDefault()?.DisplayName ?? Account.SenderName;
+
+                var profilePicture = userProfile.Photos?.FirstOrDefault()?.Url ?? string.Empty;
+
+                if (!string.IsNullOrEmpty(profilePicture))
+                {
+                    base64ProfilePicture = await GetProfilePictureBase64EncodedAsync(profilePicture).ConfigureAwait(false);
+                }
+
+                bool shouldUpdateAccountProfile = (!string.IsNullOrEmpty(senderName) && Account.SenderName != senderName)
+                    || (!string.IsNullOrEmpty(profilePicture) && Account.ProfilePictureBase64 != base64ProfilePicture);
+
+                if (!string.IsNullOrEmpty(senderName) && Account.SenderName != senderName)
+                {
+                    Account.SenderName = senderName;
+                }
+
+                if (!string.IsNullOrEmpty(profilePicture) && Account.ProfilePictureBase64 != base64ProfilePicture)
+                {
+                    Account.ProfilePictureBase64 = base64ProfilePicture;
+                }
+
+                if (shouldUpdateAccountProfile)
+                {
+                    await _gmailChangeProcessor.UpdateAccountAsync(Account).ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex, "Error while synchronizing profile information for {Name}", Account.Name);
+            }
+        }
+
+        protected override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
             _logger.Information("Internal synchronization started for {Name}", Account.Name);
 

Wino.Core/Synchronizers/ImapSynchronizer.cs

@@ -405,7 +405,7 @@ namespace Wino.Core.Synchronizers
             ];
         }
 
-        public override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
+        protected override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
             var downloadedMessageIds = new List<string>();
 

Wino.Core/Synchronizers/OutlookSynchronizer.cs

@@ -128,7 +128,7 @@ namespace Wino.Core.Synchronizers
         #endregion
 
 
-        public override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
+        protected override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
             var downloadedMessageIds = new List<string>();