Revert "File scoped namespaces"

This reverts commit d31d8f574e.

Wino.Mail/Activation/DefaultActivationHandler.cs

@@ -5,18 +5,19 @@ using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Media.Animation;
 using Wino.Views;
 
-namespace Wino.Activation;
-
-internal class DefaultActivationHandler : ActivationHandler<IActivatedEventArgs>
+namespace Wino.Activation
 {
-    protected override Task HandleInternalAsync(IActivatedEventArgs args)
+    internal class DefaultActivationHandler : ActivationHandler<IActivatedEventArgs>
     {
-        (Window.Current.Content as Frame).Navigate(typeof(AppShell), null, new DrillInNavigationTransitionInfo());
+        protected override Task HandleInternalAsync(IActivatedEventArgs args)
+        {
+            (Window.Current.Content as Frame).Navigate(typeof(AppShell), null, new DrillInNavigationTransitionInfo());
 
-        return Task.CompletedTask;
+            return Task.CompletedTask;
+        }
+
+        // Only navigate if Frame content doesn't exist.
+        protected override bool CanHandleInternal(IActivatedEventArgs args)
+            => (Window.Current?.Content as Frame)?.Content == null;
     }
-
-    // Only navigate if Frame content doesn't exist.
-    protected override bool CanHandleInternal(IActivatedEventArgs args)
-        => (Window.Current?.Content as Frame)?.Content == null;
 }

Wino.Mail/Activation/FileActivationHandler.cs

@@ -12,56 +12,57 @@ using Wino.Core.Domain.Interfaces;
 using Wino.Core.UWP.Extensions;
 using Wino.Views;
 
-namespace Wino.Activation;
-
-internal class FileActivationHandler : ActivationHandler<FileActivatedEventArgs>
+namespace Wino.Activation
 {
-    private readonly INativeAppService _nativeAppService;
-    private readonly IMimeFileService _mimeFileService;
-    private readonly IStatePersistanceService _statePersistanceService;
-    private readonly INavigationService _winoNavigationService;
-
-    public FileActivationHandler(INativeAppService nativeAppService,
-                                 IMimeFileService mimeFileService,
-                                 IStatePersistanceService statePersistanceService,
-                                 INavigationService winoNavigationService)
+    internal class FileActivationHandler : ActivationHandler<FileActivatedEventArgs>
     {
-        _nativeAppService = nativeAppService;
-        _mimeFileService = mimeFileService;
-        _statePersistanceService = statePersistanceService;
-        _winoNavigationService = winoNavigationService;
-    }
+        private readonly INativeAppService _nativeAppService;
+        private readonly IMimeFileService _mimeFileService;
+        private readonly IStatePersistanceService _statePersistanceService;
+        private readonly INavigationService _winoNavigationService;
 
-    protected override async Task HandleInternalAsync(FileActivatedEventArgs args)
-    {
-        // Always handle the last item passed.
-        // Multiple files are not supported.
-
-        var file = args.Files.Last() as StorageFile;
-
-        // Only EML files are supported now.
-        var fileExtension = Path.GetExtension(file.Path);
-
-        if (string.Equals(fileExtension, ".eml", StringComparison.OrdinalIgnoreCase))
+        public FileActivationHandler(INativeAppService nativeAppService,
+                                     IMimeFileService mimeFileService,
+                                     IStatePersistanceService statePersistanceService,
+                                     INavigationService winoNavigationService)
         {
-            var fileBytes = await file.ToByteArrayAsync();
-            var directoryName = Path.GetDirectoryName(file.Path);
+            _nativeAppService = nativeAppService;
+            _mimeFileService = mimeFileService;
+            _statePersistanceService = statePersistanceService;
+            _winoNavigationService = winoNavigationService;
+        }
 
-            var messageInformation = await _mimeFileService.GetMimeMessageInformationAsync(fileBytes, directoryName).ConfigureAwait(false);
+        protected override async Task HandleInternalAsync(FileActivatedEventArgs args)
+        {
+            // Always handle the last item passed.
+            // Multiple files are not supported.
 
-            if (_nativeAppService.IsAppRunning())
+            var file = args.Files.Last() as StorageFile;
+
+            // Only EML files are supported now.
+            var fileExtension = Path.GetExtension(file.Path);
+
+            if (string.Equals(fileExtension, ".eml", StringComparison.OrdinalIgnoreCase))
             {
-                // TODO: Activate another Window and go to mail rendering page.
-                _winoNavigationService.Navigate(WinoPage.MailRenderingPage, messageInformation, NavigationReferenceFrame.RenderingFrame);
-            }
-            else
-            {
-                _statePersistanceService.ShouldShiftMailRenderingDesign = true;
-                (Window.Current.Content as Frame).Navigate(typeof(MailRenderingPage), messageInformation, new DrillInNavigationTransitionInfo());
+                var fileBytes = await file.ToByteArrayAsync();
+                var directoryName = Path.GetDirectoryName(file.Path);
+
+                var messageInformation = await _mimeFileService.GetMimeMessageInformationAsync(fileBytes, directoryName).ConfigureAwait(false);
+
+                if (_nativeAppService.IsAppRunning())
+                {
+                    // TODO: Activate another Window and go to mail rendering page.
+                    _winoNavigationService.Navigate(WinoPage.MailRenderingPage, messageInformation, NavigationReferenceFrame.RenderingFrame);
+                }
+                else
+                {
+                    _statePersistanceService.ShouldShiftMailRenderingDesign = true;
+                    (Window.Current.Content as Frame).Navigate(typeof(MailRenderingPage), messageInformation, new DrillInNavigationTransitionInfo());
+                }
             }
         }
+
+        protected override bool CanHandleInternal(FileActivatedEventArgs args) => args.Files.Any();
+
     }
-
-    protected override bool CanHandleInternal(FileActivatedEventArgs args) => args.Files.Any();
-
 }

Wino.Mail/Activation/ProtocolActivationHandler.cs

@@ -6,54 +6,55 @@ using Wino.Core.Domain.Interfaces;
 using Wino.Core.Domain.Models.Launch;
 using Wino.Messaging.Client.Shell;
 
-namespace Wino.Activation;
-
-internal class ProtocolActivationHandler : ActivationHandler<ProtocolActivatedEventArgs>
+namespace Wino.Activation
 {
-    private const string MailtoProtocolTag = "mailto:";
-
-    private readonly INativeAppService _nativeAppService;
-    private readonly ILaunchProtocolService _launchProtocolService;
-
-    public ProtocolActivationHandler(INativeAppService nativeAppService, ILaunchProtocolService launchProtocolService)
+    internal class ProtocolActivationHandler : ActivationHandler<ProtocolActivatedEventArgs>
     {
-        _nativeAppService = nativeAppService;
-        _launchProtocolService = launchProtocolService;
-    }
+        private const string MailtoProtocolTag = "mailto:";
 
-    protected override Task HandleInternalAsync(ProtocolActivatedEventArgs args)
-    {
-        // Check URI prefix.
-        var protocolString = args.Uri.AbsoluteUri;
+        private readonly INativeAppService _nativeAppService;
+        private readonly ILaunchProtocolService _launchProtocolService;
 
-        if (protocolString.StartsWith(MailtoProtocolTag))
+        public ProtocolActivationHandler(INativeAppService nativeAppService, ILaunchProtocolService launchProtocolService)
         {
-            // mailto activation. Try to parse params.
-            _launchProtocolService.MailToUri = new MailToUri(protocolString);
+            _nativeAppService = nativeAppService;
+            _launchProtocolService = launchProtocolService;
+        }
 
-            if (_nativeAppService.IsAppRunning())
+        protected override Task HandleInternalAsync(ProtocolActivatedEventArgs args)
+        {
+            // Check URI prefix.
+            var protocolString = args.Uri.AbsoluteUri;
+
+            if (protocolString.StartsWith(MailtoProtocolTag))
             {
-                // Just send publish a message. Shell will continue.
-                WeakReferenceMessenger.Default.Send(new MailtoProtocolMessageRequested());
+                // mailto activation. Try to parse params.
+                _launchProtocolService.MailToUri = new MailToUri(protocolString);
+
+                if (_nativeAppService.IsAppRunning())
+                {
+                    // Just send publish a message. Shell will continue.
+                    WeakReferenceMessenger.Default.Send(new MailtoProtocolMessageRequested());
+                }
             }
+
+            return Task.CompletedTask;
         }
 
-        return Task.CompletedTask;
-    }
-
-    protected override bool CanHandleInternal(ProtocolActivatedEventArgs args)
-    {
-        // Validate the URI scheme.
-
-        try
+        protected override bool CanHandleInternal(ProtocolActivatedEventArgs args)
         {
-            var uriGet = args.Uri;
-        }
-        catch (UriFormatException)
-        {
-            return false;
-        }
+            // Validate the URI scheme.
 
-        return base.CanHandleInternal(args);
+            try
+            {
+                var uriGet = args.Uri;
+            }
+            catch (UriFormatException)
+            {
+                return false;
+            }
+
+            return base.CanHandleInternal(args);
+        }
     }
 }

Wino.Mail/Activation/ToastNotificationActivationHandler.cs

@@ -9,67 +9,68 @@ using Wino.Core.Domain;
 using Wino.Core.Domain.Interfaces;
 using Wino.Messaging.Client.Accounts;
 
-namespace Wino.Activation;
-
-/// <summary>
-/// This handler will only handle the toasts that runs on foreground.
-/// Background executions are not handled here like mark as read or delete.
-/// </summary>
-internal class ToastNotificationActivationHandler : ActivationHandler<ToastNotificationActivatedEventArgs>
+namespace Wino.Activation
 {
-    private readonly IMailService _mailService;
-    private readonly IFolderService _folderService;
-
-    private ToastArguments _toastArguments;
-
-    public ToastNotificationActivationHandler(IMailService mailService,
-                                              IFolderService folderService)
+    /// <summary>
+    /// This handler will only handle the toasts that runs on foreground.
+    /// Background executions are not handled here like mark as read or delete.
+    /// </summary>
+    internal class ToastNotificationActivationHandler : ActivationHandler<ToastNotificationActivatedEventArgs>
     {
-        _mailService = mailService;
-        _folderService = folderService;
-    }
+        private readonly IMailService _mailService;
+        private readonly IFolderService _folderService;
 
-    protected override async Task HandleInternalAsync(ToastNotificationActivatedEventArgs args)
-    {
-        // Create the mail item navigation event.
-        // If the app is running, it'll be picked up by the Messenger.
-        // Otherwise we'll save it and handle it when the shell loads all accounts.
+        private ToastArguments _toastArguments;
 
-        // Parse the mail unique id and perform above actions.
-        if (Guid.TryParse(_toastArguments[Constants.ToastMailUniqueIdKey], out Guid mailItemUniqueId))
+        public ToastNotificationActivationHandler(IMailService mailService,
+                                                  IFolderService folderService)
         {
-            var account = await _mailService.GetMailAccountByUniqueIdAsync(mailItemUniqueId).ConfigureAwait(false);
-            if (account == null) return;
-
-            var mailItem = await _mailService.GetSingleMailItemAsync(mailItemUniqueId).ConfigureAwait(false);
-            if (mailItem == null) return;
-
-            var message = new AccountMenuItemExtended(mailItem.AssignedFolder.Id, mailItem);
-
-            // Delegate this event to LaunchProtocolService so app shell can pick it up on launch if app doesn't work.
-            var launchProtocolService = App.Current.Services.GetService<ILaunchProtocolService>();
-            launchProtocolService.LaunchParameter = message;
-
-            // Send the messsage anyways. Launch protocol service will be ignored if the message is picked up by subscriber shell.
-            WeakReferenceMessenger.Default.Send(message);
-        }
-    }
-
-    protected override bool CanHandleInternal(ToastNotificationActivatedEventArgs args)
-    {
-        try
-        {
-            _toastArguments = ToastArguments.Parse(args.Argument);
-
-            return
-                _toastArguments.Contains(Constants.ToastMailUniqueIdKey) &&
-                _toastArguments.Contains(Constants.ToastActionKey);
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Couldn't handle parsing toast notification arguments for foreground navigate.");
+            _mailService = mailService;
+            _folderService = folderService;
         }
 
-        return false;
+        protected override async Task HandleInternalAsync(ToastNotificationActivatedEventArgs args)
+        {
+            // Create the mail item navigation event.
+            // If the app is running, it'll be picked up by the Messenger.
+            // Otherwise we'll save it and handle it when the shell loads all accounts.
+
+            // Parse the mail unique id and perform above actions.
+            if (Guid.TryParse(_toastArguments[Constants.ToastMailUniqueIdKey], out Guid mailItemUniqueId))
+            {
+                var account = await _mailService.GetMailAccountByUniqueIdAsync(mailItemUniqueId).ConfigureAwait(false);
+                if (account == null) return;
+
+                var mailItem = await _mailService.GetSingleMailItemAsync(mailItemUniqueId).ConfigureAwait(false);
+                if (mailItem == null) return;
+
+                var message = new AccountMenuItemExtended(mailItem.AssignedFolder.Id, mailItem);
+
+                // Delegate this event to LaunchProtocolService so app shell can pick it up on launch if app doesn't work.
+                var launchProtocolService = App.Current.Services.GetService<ILaunchProtocolService>();
+                launchProtocolService.LaunchParameter = message;
+
+                // Send the messsage anyways. Launch protocol service will be ignored if the message is picked up by subscriber shell.
+                WeakReferenceMessenger.Default.Send(message);
+            }
+        }
+
+        protected override bool CanHandleInternal(ToastNotificationActivatedEventArgs args)
+        {
+            try
+            {
+                _toastArguments = ToastArguments.Parse(args.Argument);
+
+                return
+                    _toastArguments.Contains(Constants.ToastMailUniqueIdKey) &&
+                    _toastArguments.Contains(Constants.ToastActionKey);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Couldn't handle parsing toast notification arguments for foreground navigate.");
+            }
+
+            return false;
+        }
     }
 }