Addition of methods for loading saved files from streaming assets to support built-in saves

Author: Cory Leach

Runtime/SaveLoadManager.cs

@@ -13,18 +13,18 @@ public class SaveLoadManager : ScriptableObject
     {
         [Header("Settings"),SerializeField] private string defaultFolder = "SaveData";
         public string DefaultFolder => defaultFolder;
-        
+
         [SerializeField] private string baseFolder = "GameData";
         public string BaseFolder => baseFolder;
-        
+
         [SerializeField] private SerializationMethodType saveMethod = SerializationMethodType.Default;
 
         [Header("Encryption"),SerializeField] protected string key = string.Empty;
         public string Key => key;
-        
+
         [SerializeField] protected string salt = string.Empty;
         public string Salt => salt;
-        
+
         private Dictionary<SerializationMethodType, ISerializationMethod> _methods;
 
         private void OnEnable()
@@ -53,10 +53,10 @@ public static SaveLoadManager Create(string baseFolder, string defaultFolder, Se
             instance.key = key;
             instance.salt = salt;
             instance.saveMethod = saveMethod;
-            
+
             return instance;
         }
-        
+
         /// <summary>
         /// Save an object to disk
         /// </summary>
@@ -77,14 +77,31 @@ public void Save(object obj, string filename, string folder = null)
         /// Gets the list of save files that have been created
         /// </summary>
         /// <param name="folder">sub folder</param>
+        /// <param name="streamingAssets">Will use Application.streamingAssetsPath as base path if true otherwise Application.persistentDataPath</param>
+        /// <returns>list of file names (excludes the path)</returns>
+        public string[] GetFiles(string folder = null, bool streamingAssets = false)
+        {
+            if (string.IsNullOrEmpty(folder))
+            {
+                folder = defaultFolder;
+            }
+            return SaveLoadUtility.GetSavedFiles(folder,baseFolder, streamingAssets);
+        }
+
+        /// <summary>
+        /// Gets the list of save files that have been created
+        /// </summary>
+        /// <param name="list">list to be populated with file names</param>
+        /// <param name="folder">sub folder</param>
+        /// <param name="streamingAssets">Will use Application.streamingAssetsPath as base path if true otherwise Application.persistentDataPath</param>
         /// <returns>list of file names (excludes the path)</returns>
-        public string[] GetFiles(string folder = null)
+        public void GetFiles(List<string> list, string folder = null, bool streamingAssets = false)
         {
             if (string.IsNullOrEmpty(folder))
             {
                 folder = defaultFolder;
             }
-            return SaveLoadUtility.GetSavedFiles(folder,baseFolder);
+            SaveLoadUtility.GetSavedFiles(list, folder,baseFolder, streamingAssets);
         }
 
         /// <summary>
@@ -119,17 +136,18 @@ public T Copy<T>(T obj)
             var saveLoadMethod = GetSaveLoadMethod(saveMethod);
             return (T)saveLoadMethod.Copy(obj);
         }
-        
+
         /// <summary>
         /// Load an object from disk
         /// </summary>
         /// <param name="filename">Name of file to load from</param>
         /// <param name="folder">Name of folder containing the file</param>
+        /// <param name="streamingAssets">Load file from streaming assets</param>
         /// <typeparam name="T">Type of object to be loaded from file</typeparam>
         /// <returns>Instance of object loaded from file</returns>
-        public T Load<T>(string filename, string folder = null)
+        public T Load<T>(string filename, string folder = null, bool streamingAssets = false)
         {
-            return (T)Load(typeof(T), filename, folder);
+            return (T)Load(typeof(T), filename, folder, streamingAssets);
         }
 
         /// <summary>
@@ -138,15 +156,16 @@ public T Load<T>(string filename, string folder = null)
         /// <param name="type">Type of object to be loaded</param>
         /// <param name="filename">Name of file to load object from</param>
         /// <param name="folder">Name of folder containing the file to be loaded</param>
+        /// <param name="streamingAssets">Load file from streaming assets</param>
         /// <returns>Instance of object to be loaded. Null if file did not exist.</returns>
-        public object Load(Type type, string filename, string folder = null)
+        public object Load(Type type, string filename, string folder = null, bool streamingAssets = false)
         {
             if (string.IsNullOrEmpty(folder))
             {
                 folder = defaultFolder;
             }
             var saveLoadMethod = GetSaveLoadMethod(saveMethod);
-            return SaveLoadUtility.Load(type, saveLoadMethod,filename,folder, baseFolder);
+            return SaveLoadUtility.Load(type, saveLoadMethod,filename,folder, baseFolder, streamingAssets);
         }
 
         /// <summary>
@@ -162,7 +181,7 @@ public void DeleteSave(string filename, string folder = null)
             }
             SaveLoadUtility.DeleteSavedFile(filename,folder, baseFolder);
         }
-        
+
         /// <summary>
         /// Save object to file and specify the method of save/load
         /// </summary>
@@ -217,7 +236,7 @@ public void SaveUnityObject(UnityEngine.Object unityObj, string filename, string
             {
                 jsonData = JsonUtility.ToJson(unityObj)
             };
-            
+
             Save(savedObj,filename,folder);
         }
 
@@ -233,12 +252,12 @@ public void SaveUnityObject(UnityEngine.Object unityObj, string filename, string
         public bool LoadUnityObjectOverwrite(UnityEngine.Object objectToOverwrite, string filename, string folder = null)
         {
             var savedObj = Load<JsonSerializedUnityObject>(filename, folder);
-            
+
             if (savedObj == null || string.IsNullOrEmpty(savedObj.jsonData))
             {
                 return false;
             }
-            
+
             JsonUtility.FromJsonOverwrite(savedObj.jsonData,objectToOverwrite);
             return true;
         }
@@ -253,7 +272,7 @@ public void CopyUnityObjectOverwrite(UnityEngine.Object toCopy, UnityEngine.Obje
             var jsonData = JsonUtility.ToJson(toCopy);
             JsonUtility.FromJsonOverwrite(jsonData,toOverwrite);
         }
-        
+
         /// <summary>
         /// JsonSerializedUnityObject
         /// Wrapper for json data created when using Unity's JsonUtility to serialize an object derived from UnityEngine.Object
@@ -280,7 +299,7 @@ public void SetCustomSerializationMethod(ISerializationMethod customSerializatio
             }
             _methods[SerializationMethodType.Custom] = customSerializationMethod;
         }
-        
+
         private ISerializationMethod GetSaveLoadMethod(SerializationMethodType methodType)
         {
             if (_methods == null)
@@ -305,14 +324,14 @@ private ISerializationMethod GetSaveLoadMethod(SerializationMethodType methodTyp
                 case SerializationMethodType.UnityJson:
                     method = new SerializationMethodUnityJson();
                     break;
-                
+
                 case SerializationMethodType.BinaryEncrypted:
                     method = new SerializationMethodBinaryEncrypted(key,salt);
                     break;
                 case SerializationMethodType.UnityJsonEncrypted:
                     method = new SerializationMethodUnityJsonEncrypted(key,salt);
                     break;
-                
+
 #if JSON_DOT_NET
                 case SerializationMethodType.JsonDotNet:
                     method = new SerializationMethodJsonDotNet();
@@ -321,19 +340,17 @@ private ISerializationMethod GetSaveLoadMethod(SerializationMethodType methodTyp
                     method = new SerializationMethodJsonDotNetEncrypted(key,salt);
                     break;
 #endif
-                
+
                 case SerializationMethodType.Custom:
                     throw new MissingComponentException("SerializationMethodType is Custom but no custom ISerializationMethod was found.");
                 default:
                     throw new ArgumentOutOfRangeException(nameof(methodType), methodType, "SaveLoadMethodType not supported");
             }
 
             _methods[methodType] = method;
-            
+
             return method;
         }
-        
-    }    
-}
-
 
+    }
+}

Runtime/SaveLoadUtility.cs

@@ -10,12 +10,12 @@ public static class SaveLoadUtility
         //Default folder name will be used if none is provided.
         private const string DefaultFolderName = "SaveLoad";
         private const string DefaultBaseFolderPath = "GameData";
-        
-        public static string GetSavePath(string folderName = null, string baseFolderPath = null)
+
+        public static string GetSavePath(string folderName = null, string baseFolderPath = null, bool streamingAssets = false)
         {
-            return GetRuntimeSavePath(folderName, baseFolderPath);
+            return !streamingAssets ? GetRuntimeSavePath(folderName, baseFolderPath) : GetStreamingAssetsSavePath(folderName, baseFolderPath);
         }
-        
+
         public static string GetRuntimeSavePath(string folderName = null, string baseFolderPath = null)
         {
             if (string.IsNullOrEmpty(folderName))
@@ -29,22 +29,39 @@ public static string GetRuntimeSavePath(string folderName = null, string baseFol
             }
 
             var savePath = $"{Application.persistentDataPath}/{baseFolderPath}/";
-            savePath = savePath + folderName + "/";
+            savePath = $"{savePath}{folderName}/";
+            return savePath;
+        }
+
+        public static string GetStreamingAssetsSavePath(string folderName = null, string baseFolderPath = null)
+        {
+            if (string.IsNullOrEmpty(folderName))
+            {
+                folderName = DefaultFolderName;
+            }
+
+            if (string.IsNullOrEmpty(baseFolderPath))
+            {
+                baseFolderPath = DefaultBaseFolderPath;
+            }
+
+            var savePath = $"{Application.streamingAssetsPath}/{baseFolderPath}/";
+            savePath = $"{savePath}{folderName}/";
             return savePath;
         }
 
         /// <summary>
-        /// 
+        ///
         /// </summary>
         /// <param name="fileName"></param>
         /// <returns></returns>
         private static string GetSaveFileName(string fileName)
         {
             return fileName;
         }
-        
+
         /// <summary>
-        /// 
+        ///
         /// </summary>
         /// <param name="saveObject"></param>
         /// <param name="serializationMethod"></param>
@@ -55,7 +72,7 @@ public static void Save(object saveObject, ISerializationMethod serializationMet
         {
             var savePath = GetSavePath(folderName,baseFolderPath);
             var saveFilename = GetSaveFileName(filename);
-            
+
             //Create directory if it does not exist
             if (!Directory.Exists(savePath))
             {
@@ -77,10 +94,11 @@ public static void Save(object saveObject, ISerializationMethod serializationMet
         /// <param name="filename"></param>
         /// <param name="folderName"></param>
         /// <param name="baseFolderPath"></param>
+        /// <param name="streamingAssets"></param>
         /// <returns></returns>
-        public static object Load(System.Type objectType, ISerializationMethod serializationMethod, string filename, string folderName = null, string baseFolderPath = null)
+        public static object Load(System.Type objectType, ISerializationMethod serializationMethod, string filename, string folderName = null, string baseFolderPath = null, bool streamingAssets = false)
         {
-            var savePath = GetSavePath(folderName, baseFolderPath);
+            var savePath = GetSavePath(folderName, baseFolderPath, streamingAssets);
             var saveFilename = savePath + GetSaveFileName(filename);
 
             object returnObject = null;
@@ -95,43 +113,59 @@ public static object Load(System.Type objectType, ISerializationMethod serializa
                 returnObject = serializationMethod.Load(objectType, saveFile);
                 saveFile.Close();
             }
-            
+
             return returnObject;
         }
-        
+
         /// <summary>
         /// Enumerate files in the save directory
         /// </summary>
         /// <param name="folderName">folder containing the save files</param>
         /// <param name="baseFolderPath">base path to the folder</param>
+        /// <param name="streamingAssets">Will use Application.streamingAssetsPath as base path if true otherwise Application.persistentDataPath</param>
         /// <returns>list of file names</returns>
-        public static IEnumerable<string> EnumerateSavedFiles(string folderName = null, string baseFolderPath = null)
+        public static IEnumerable<string> EnumerateSavedFiles(string folderName = null, string baseFolderPath = null, bool streamingAssets = false)
         {
-            var savePath = GetSavePath(folderName,baseFolderPath);
-            
+            var savePath = GetSavePath(folderName,baseFolderPath,streamingAssets);
+
             //If directory does not exist we're done
             if (!Directory.Exists(savePath))
             {
                 yield break;
             }
-            
+
             foreach ( var file in Directory.EnumerateFiles(savePath,"*",SearchOption.AllDirectories) )
             {
                 yield return Path.GetFileName(file);
             }
         }
-        
+
         /// <summary>
         /// Creates an array list of save files in the given folder and path
         /// </summary>
         /// <param name="folderName"></param>
         /// <param name="baseFolderPath"></param>
+        /// <param name="streamingAssets">Will use Application.streamingAssetsPath as base path if true otherwise Application.persistentDataPath</param>
         /// <returns>Array of file names</returns>
-        public static string[] GetSavedFiles(string folderName = null, string baseFolderPath = null)
+        public static string[] GetSavedFiles(string folderName = null, string baseFolderPath = null, bool streamingAssets = false)
         {
             return EnumerateSavedFiles(folderName, baseFolderPath).ToArray();
         }
-        
+
+        /// <summary>
+        /// Populates a given array with a list of save files in the given folder and path
+        /// </summary>
+        /// <param name="list">list to be populated with file names</param>
+        /// <param name="folderName"></param>
+        /// <param name="baseFolderPath"></param>
+        /// <param name="streamingAssets">Will use Application.streamingAssetsPath as base path if true otherwise Application.persistentDataPath</param>
+        /// <returns>Array of file names</returns>
+        public static void GetSavedFiles(List<string> list, string folderName = null, string baseFolderPath = null, bool streamingAssets = false)
+        {
+            list.Clear();
+            list.AddRange(EnumerateSavedFiles(folderName, baseFolderPath, streamingAssets));
+        }
+
         /// <summary>
         /// Check if a saved file exists
         /// </summary>
@@ -175,10 +209,8 @@ public static void DeleteDirectory(string path)
             {
                 DeleteDirectory(dir);
             }
-            
+
             Directory.Delete(path,false);
         }
     }
 }
-
-