Fixed crash on app launch (#2648)

Author: gave92

Files/Controllers/TerminalController.cs

@@ -1,4 +1,5 @@
 using Files.DataModels;
+using Files.Filesystem;
 using Newtonsoft.Json;
 using System;
 using System.IO;
@@ -11,9 +12,7 @@ public class TerminalController : IJson
     {
         private string defaultTerminalPath = "ms-appx:///Assets/terminal/terminal.json";
 
-        private StorageFile JsonFile { get; set; }
-
-        private StorageFolder Folder { get; set; }
+        private string folderPath => Path.Combine(ApplicationData.Current.LocalFolder.Path, "settings");
 
         public TerminalFileModel Model { get; set; }
 
@@ -26,45 +25,69 @@ public TerminalController()
 
         private async Task LoadAsync()
         {
-            Folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("settings", CreationCollisionOption.OpenIfExists);
-            try
+            StorageFolder Folder = await FilesystemTasks.Wrap(() => ApplicationData.Current.LocalFolder.CreateFolderAsync("settings", CreationCollisionOption.OpenIfExists).AsTask());
+            if (Folder == null)
             {
-                JsonFile = await Folder.GetFileAsync(JsonFileName);
+                Model = await GetDefaultTerminalFileModel();
+                return;
             }
-            catch (FileNotFoundException)
-            {
-                var defaultFile = StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));
 
-                JsonFile = await Folder.CreateFileAsync(JsonFileName);
-                await FileIO.WriteBufferAsync(JsonFile, await FileIO.ReadBufferAsync(await defaultFile));
+            var JsonFile = await FilesystemTasks.Wrap(() => Folder.GetFileAsync(JsonFileName).AsTask());
+            if (!JsonFile)
+            {
+                if (JsonFile == FilesystemErrorCode.ERROR_NOTFOUND)
+                {
+                    Model = await GetDefaultTerminalFileModel();
+                    SaveModel();
+                    return;
+                }
+                else
+                {
+                    Model = await GetDefaultTerminalFileModel();
+                    return;
+                }
             }
 
-            var content = await FileIO.ReadTextAsync(JsonFile);
-
             try
             {
+                var content = await FileIO.ReadTextAsync(JsonFile.Result);
                 Model = JsonConvert.DeserializeObject<TerminalFileModel>(content);
                 if (Model == null)
                 {
-                    Model = new TerminalFileModel();
                     throw new JsonParsingNullException(JsonFileName);
                 }
             }
             catch (JsonParsingNullException)
             {
-                var defaultFile = StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));
-
-                JsonFile = await Folder.CreateFileAsync(JsonFileName, CreationCollisionOption.ReplaceExisting);
-                await FileIO.WriteBufferAsync(JsonFile, await FileIO.ReadBufferAsync(await defaultFile));
-                var defaultContent = await FileIO.ReadTextAsync(JsonFile);
-                Model = JsonConvert.DeserializeObject<TerminalFileModel>(defaultContent);
+                Model = await GetDefaultTerminalFileModel();
+                SaveModel();
             }
             catch (Exception)
             {
-                var defaultFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));
-                JsonFile = null;
+                Model = await GetDefaultTerminalFileModel();
+            }
+        }
+
+        private async Task<TerminalFileModel> GetDefaultTerminalFileModel()
+        {
+            try
+            {
+                StorageFile defaultFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));
                 var defaultContent = await FileIO.ReadTextAsync(defaultFile);
-                Model = JsonConvert.DeserializeObject<TerminalFileModel>(defaultContent);
+                return JsonConvert.DeserializeObject<TerminalFileModel>(defaultContent);
+            }
+            catch
+            {
+                var model = new TerminalFileModel();
+                model.Terminals.Add(new Terminal()
+                {
+                    Name = "CMD",
+                    Path = "cmd.exe",
+                    Arguments = "",
+                    Icon = ""
+                });
+                model.ResetToDefaultTerminal();
+                return model;
             }
         }
 
@@ -102,16 +125,17 @@ public async Task GetInstalledTerminalsAsync()
 
         public void SaveModel()
         {
-            if (JsonFile == null)
+            try
             {
-                return;
+                using (var file = File.CreateText(Path.Combine(folderPath, JsonFileName)))
+                {
+                    JsonSerializer serializer = new JsonSerializer();
+                    serializer.Formatting = Formatting.Indented;
+                    serializer.Serialize(file, Model);
+                }
             }
-
-            using (var file = File.CreateText(Folder.Path + Path.DirectorySeparatorChar + JsonFileName))
+            catch
             {
-                JsonSerializer serializer = new JsonSerializer();
-                serializer.Formatting = Formatting.Indented;
-                serializer.Serialize(file, Model);
             }
         }
     }

Files/Helpers/RegistryHelper.cs

@@ -5,25 +5,29 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Security;
 using System.Text;
 using System.Threading.Tasks;
 using Windows.Storage;
 
 namespace Files.Helpers
 {
-    public class RegistryHelper
+    public static class RegistryHelper
     {
         public static async Task<List<ShellNewEntry>> GetNewContextMenuEntries()
         {
             var newMenuItems = new List<ShellNewEntry>();
             foreach (var keyName in Registry.ClassesRoot.GetSubKeyNames()
                 .Where(x => x.StartsWith(".") && !new string[] { ".library-ms", ".url", ".lnk" }.Contains(x)))
             {
-                using var key = Registry.ClassesRoot.OpenSubKey(keyName);
-                var ret = await GetShellNewRegistryEntries(key, key);
-                if (ret != null)
+                using var key = Registry.ClassesRoot.OpenSubKeySafe(keyName);
+                if (key != null)
                 {
-                    newMenuItems.Add(ret);
+                    var ret = await GetShellNewRegistryEntries(key, key);
+                    if (ret != null)
+                    {
+                        newMenuItems.Add(ret);
+                    }
                 }
             }
             return newMenuItems;
@@ -32,15 +36,19 @@ public static async Task<List<ShellNewEntry>> GetNewContextMenuEntries()
         public static async Task<ShellNewEntry> GetNewContextMenuEntryForType(string extension)
         {
             if (string.IsNullOrEmpty(extension)) return null;
-            using var key = Registry.ClassesRoot.OpenSubKey(extension);
+            using var key = Registry.ClassesRoot.OpenSubKeySafe(extension);
             return key != null ? await GetShellNewRegistryEntries(key, key) : null;
         }
 
         private static async Task<ShellNewEntry> GetShellNewRegistryEntries(RegistryKey current, RegistryKey root)
         {
             foreach (var keyName in current.GetSubKeyNames())
             {
-                using var key = current.OpenSubKey(keyName);
+                using var key = current.OpenSubKeySafe(keyName);
+                if (key == null)
+                {
+                    continue;
+                }
                 if (keyName == "ShellNew")
                 {
                     return await ParseShellNewRegistryEntry(key, root);
@@ -108,5 +116,17 @@ private static async Task<ShellNewEntry> ParseShellNewRegistryEntry(RegistryKey
 
             return entry;
         }
+
+        private static RegistryKey OpenSubKeySafe(this RegistryKey root, string keyName)
+        {
+            try
+            {
+                return root.OpenSubKey(keyName);
+            }
+            catch (SecurityException)
+            {
+                return null;
+            }
+        }
     }
 }