Feature/ad blocking

source/Roam.macOS/AppDelegate.cs

@@ -6,6 +6,7 @@
 using Microsoft.AppCenter;
 using Microsoft.AppCenter.Analytics;
 using Microsoft.AppCenter.Crashes;
+using WebKit;
 
 namespace Roam.macOS
 {
@@ -15,32 +16,85 @@ public partial class AppDelegate : NSApplicationDelegate, INSWindowRestoration
         const string AppCenterKey = "36109d82-252b-4bd5-b3c7-3fa12c15457e";
 
         private static WindowRestorer windowRestorer;
+        private Task<WKContentRuleList> contentBlockerLoading;
+
+        private bool firstContentRuleAccess = true;
+        private WKContentRuleList _contentRuleList;
+        public WKContentRuleList ContentRuleList
+        {
+            get
+            {
+                if(_contentRuleList is null)
+                {
+                    if (contentBlockerLoading.IsCompleted)
+                    {
+                        _contentRuleList = contentBlockerLoading.Result;
+                    }
+                    else if(firstContentRuleAccess)
+                    {
+                        firstContentRuleAccess = false;
+
+                        Help.Logger.WriteWarning("ContentRuleList was not compiled by the time of first access");
+                    }
+                }
+
+                return _contentRuleList;
+            }
+        }
 
         //TODO: Make this a download manager, implement the cookie thing?, and add it to appdelegate
         public Downloader downloader;
 
         public AppDelegate()
         {
+            AppCenter.Start($"macos={AppCenterKey};", typeof(Analytics), typeof(Crashes));
 
+            RegisterForAppEvents();
+
+            contentBlockerLoading = ContentBlocking.PrepareRuleList();
         }
 
         public override void DidFinishLaunching(NSNotification notification)
         {
-            AppCenter.Start($"macos={AppCenterKey};", typeof(Analytics), typeof(Crashes));
+            try
+            {
 
 #if !DEBUG
-            Help.Logger.RedirectConsoleLogging();
+                Help.Logger.RedirectConsoleLogging();
 #endif
 
+                Help.StartUp.Run();
+
+                NSUserDefaults.StandardUserDefaults.SetBool(true, "NSQuitAlwaysKeepsWindows");
+
+                CompleteWindowLaunchProcess();
+            }
+            catch (Exception ex)
+            {
+                Crashes.TrackError(ex);
+            }
+        }
+
+        #region General App Events
+        private void RegisterForAppEvents()
+        {
             AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
             TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
+        }
 
-            Help.StartUp.Run();
+        private void DeregisterForAppEvents()
+        {
+            AppDomain.CurrentDomain.UnhandledException -= CurrentDomain_UnhandledException;
+            TaskScheduler.UnobservedTaskException -= TaskScheduler_UnobservedTaskException;
+        }
 
-            NSUserDefaults.StandardUserDefaults.SetBool(true, "NSQuitAlwaysKeepsWindows");
+        private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) =>
+    Help.Logger.WriteUnhandledException(sender, e);
 
-            CompleteWindowLaunchProcess();
-        }
+        private void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e) =>
+            Help.Logger.WriteUnobservedTaskException(sender, e);
+
+        #endregion
 
         #region UI Menu Actions
         partial void OpenSpacesMenuClicked(NSObject sender)
@@ -102,26 +156,6 @@ private void CompleteWindowLaunchProcess()
             }
         }
 
-        private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
-        {
-            System.Console.WriteLine($"**{(e.IsTerminating ? "CRASHING:" : "")} UNHANDLED EXCEPTION");
-
-            if(e.ExceptionObject is Exception exception)
-            {
-                System.Console.WriteLine($"  {exception.Message}");
-            }
-            else
-            {
-                System.Console.WriteLine($"  non-exception object of type {e.ExceptionObject.GetType()}: {e.ExceptionObject}");
-            }
-        }
-
-        private void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
-        {
-            System.Console.WriteLine("**UNOBSERVED TASK EXCEPTION: In an async Task");
-            System.Console.WriteLine("  " + e.Exception.Message);
-        }
-
         /// <summary>
         /// Restores a window that AppKit saved. This is called for each restorable window detected. On it's first run,
         /// it instantiates the WindowRestorer that this AppDelegate will hold, statically (by requirement),

source/Roam.macOS/Common/ContentBlocker.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Threading.Tasks;
+using Foundation;
+using WebKit;
+
+namespace Roam.macOS
+{
+    public static class ContentBlocking
+    {
+        private const string DefaultListIdentifier = "RoamContentBlockingList";
+
+        public static async Task<WKContentRuleList> PrepareRuleList()
+        {
+            var ruleStore = WKContentRuleListStore.FromUrl(Help.FileSystem.ContentStoreDirectory);
+
+            // LookUpContentRule throws an exception if unavailable, so we wrap it in try catch and use
+            // it as a signal to know the rulelist hasnt been compiled yet (first run of the app, probably)
+            //
+            // We could check what rules are available but that is another async call that, in testing,
+            // typically means the first WKWebView is created prior to rulelist being retreived
+            try
+            {
+                return await ruleStore.LookUpContentRuleListAsync(DefaultListIdentifier);
+            }
+            catch (Exception ex)
+            {
+                return await CompileBlockingList(ruleStore);
+            }
+        }
+
+        private static async Task<WKContentRuleList> CompileBlockingList(WKContentRuleListStore ruleStore)
+        {
+            string resourceName = "safariTestBase";
+
+            try
+            {
+                if (NSBundle.MainBundle.PathForResource(resourceName, "json") is string blockListPath)
+                {
+                    if (await File.ReadAllTextAsync(blockListPath) is string rulesJson)
+                    {
+                        if (await ruleStore.CompileContentRuleListAsync(DefaultListIdentifier, rulesJson)
+                            is WKContentRuleList compiledRuleList)
+                        {
+                            return compiledRuleList;
+                        }
+                        else LogError("Unable to compile the rule list.");
+                    }
+                    else LogError("Unable to find block list in bundled resource");
+                }
+                else LogError("Unable to read the block list from resource bundle.");
+            }
+            catch (Exception ex)
+            {
+                Help.Logger.WriteException(ex, "EXCEPTION while compile the rule list.");
+            }
+
+            return null;
+
+            void LogError(string message)
+            {
+                Help.Logger.WriteError(message);
+            }
+        }
+    }
+}

source/Roam.macOS/Common/Controls/RWKWebView/RWKUIDelegate.cs

@@ -1,4 +1,5 @@
-using WebKit;
+using AppKit;
+using WebKit;
 
 namespace Roam.macOS
 {
@@ -16,6 +17,10 @@ public override WKWebView CreateWebView(WKWebView webView,
                                                 WKNavigationAction navigationAction,
                                                 WKWindowFeatures windowFeatures)
         {
+            if(((AppDelegate)NSApplication.SharedApplication.Delegate).ContentRuleList is WKContentRuleList ruleList)
+            {
+                configuration.UserContentController.AddContentRuleList(ruleList);
+            }
 
             switch (navigationAction.NavigationType)
             {

source/Roam.macOS/Helpers/FileSystem.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Foundation;
 
 namespace Roam.macOS
 {
@@ -9,6 +10,9 @@ public static class FileSystem
         {
             private const string devAppName = "Roam-Dev";
             private const string appName = "Roam";
+            private const string contentRuleStoreName = "content-blocking";
+
+            private static string contentStoreFolder => Path.Combine(CurrentRoamAppSupportFolder, contentRuleStoreName);
 
             public static string DevRoamAppSupportFolder => Path.Combine(AppSupportFolder, devAppName);
             public static string ReleaseRoamAppSupportFolder => Path.Combine(AppSupportFolder, appName);
@@ -20,6 +24,9 @@ public static class FileSystem
                 ReleaseRoamAppSupportFolder;
 #endif
 
+            public static NSUrl ContentStoreDirectory =>
+                new NSUrl(Path.Combine(CurrentRoamAppSupportFolder, contentRuleStoreName), isDir: true);
+
             private static string AppSupportFolder
             {
                 get
@@ -29,6 +36,12 @@ private static string AppSupportFolder
                     return Path.Combine(libraryFolder, "Application Support");
                 }
             }
+
+            public static void EnsureAppsFileStructureExists()
+            {
+                Directory.CreateDirectory(CurrentRoamAppSupportFolder);
+                Directory.CreateDirectory(contentStoreFolder);
+            }
         }
     }
 }

source/Roam.macOS/Helpers/Logger.cs

@@ -1,15 +1,31 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Microsoft.AppCenter.Analytics;
+using Microsoft.AppCenter.Crashes;
 
 namespace Roam.macOS
 {
     public static partial class Help
     {
+        internal class UnknownUnhandledException : Exception
+        {
+            public UnknownUnhandledException()
+            {
+
+            }
+        }
+
         public static class Logger
         {
+            private const string GeneralErrorEvent = nameof(GeneralErrorEvent);
+            private const string GeneralWarningEvent = nameof(GeneralWarningEvent);
+
             public static string LogFile => Path.Combine(Help.FileSystem.CurrentRoamAppSupportFolder, "log.txt");
 
+
             public static void RedirectConsoleLogging()
             {
                 var fileStream = new FileStream(Help.Logger.LogFile, FileMode.Append);
@@ -33,6 +49,12 @@ public static void WriteInvalidStateError(string infoMessage, [CallerMemberName]
                 //This represents an error that should never happen, so a breakpoint should be kept here to flag us in debug, no matter what we're doing.
                 System.Console.WriteLine($"  INVALID-STATE found within {callerMember}");
                 System.Console.WriteLine($"   -info: {infoMessage}");
+
+                Crashes.TrackError(new IllegalAppStateRepresented(), new Dictionary<string, string>
+                {
+                    { "caller", callerMember },
+                    { "message", infoMessage },
+                });
             }
 
             /// <summary>
@@ -42,7 +64,24 @@ public static void WriteInvalidStateError(string infoMessage, [CallerMemberName]
             /// <param name="callerMember"></param>
             public static void WriteWarning(string warningMessage, [CallerMemberName] string callerMember = "")
             {
-                System.Console.WriteLine($"  Warning from {callerMember}: {warningMessage}");
+                Analytics.TrackEvent(GeneralWarningEvent, new Dictionary<string, string>
+                {
+                    { "caller", callerMember },
+                    { "message", warningMessage },
+                });
+
+                System.Diagnostics.Debug.WriteLine($"  Warning from {callerMember}: {warningMessage}");
+            }
+
+            public static void WriteError(string errorMessage, [CallerMemberName] string callerMember = "")
+            {
+                Analytics.TrackEvent(GeneralErrorEvent, new Dictionary<string, string>
+                {
+                    { "caller", callerMember },
+                    { "message", errorMessage },
+                });
+
+                System.Diagnostics.Debug.WriteLine($"  Error from {callerMember}: {errorMessage}");
             }
 
             /// <summary>
@@ -56,6 +95,31 @@ public static void WriteException(Exception ex, string infoMessage, [CallerMembe
                 System.Console.WriteLine($"  Exception occurred and caught within {callerMember}");
                 System.Console.WriteLine($"   -info: {infoMessage}");
                 System.Console.WriteLine($"   -ex: {ex.Message}");
+
+                Crashes.TrackError(ex, new Dictionary<string, string>() { { "message", infoMessage } });
+            }
+
+            public static void WriteUnhandledException(object sender, UnhandledExceptionEventArgs e)
+            {
+                System.Console.WriteLine($"**{(e.IsTerminating ? "CRASHING:" : "")} UNHANDLED EXCEPTION");
+
+                if (e.ExceptionObject is Exception exception)
+                {
+                    Crashes.TrackError(exception, new Dictionary<string, string>() { { "isTerminating", e.IsTerminating.ToString() } });
+
+                    System.Console.WriteLine($"  {exception.Message}");
+                }
+                else
+                {
+                    Crashes.TrackError(new UnknownUnhandledException(), new Dictionary<string, string>() { { "isTerminating", e.IsTerminating.ToString() } });
+
+                    System.Console.WriteLine($"  non-exception object of type {e.ExceptionObject.GetType()}: {e.ExceptionObject}");
+                }
+            }
+
+            public static void WriteUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
+            {
+                WriteException(e.Exception, $"Unobserved task exception in async task,  {e.Exception.Message}");
             }
 
             private static void WriteBeginSessionMessage()

source/Roam.macOS/Helpers/Startup.cs

@@ -16,13 +16,11 @@ public static class StartUp
 
             public static void Run()
             {
-                EnsureFileStructureExists();
+                Help.FileSystem.EnsureAppsFileStructureExists();
+
                 VerifyRealmFiles();
             }
 
-            private static void EnsureFileStructureExists() =>
-                Directory.CreateDirectory(Help.FileSystem.CurrentRoamAppSupportFolder);
-
             private static void VerifyRealmFiles()
             {
                 bool databaseNeedsCreated = !File.Exists(Help.RealmDB.RealmPath);