From d64a7d677735a600c1b0217e9159fa1348ac3c8f Mon Sep 17 00:00:00 2001 From: ALEXTANG <574809918@qq.com> Date: Fri, 12 May 2023 22:36:06 +0800 Subject: [PATCH] [+] PlayerPrefsEditor --- Assets/TEngine/Editor/PlayerPrefsEditor.meta | 8 + .../Editor/PlayerPrefsEditor/Editor.meta | 8 + .../Editor/ImportPlayerPrefsWizard.cs | 42 + .../Editor/ImportPlayerPrefsWizard.cs.meta | 11 + .../Editor/PlayerPrefsEditor/Editor/Mac.meta | 9 + .../PlayerPrefsEditor/Editor/Mac/Plist.cs | 966 +++++++++++++ .../Editor/Mac/Plist.cs.meta | 12 + .../Editor/PlayerPrefsEditor.cs | 1257 +++++++++++++++++ .../Editor/PlayerPrefsEditor.cs.meta | 12 + .../Editor/PlayerPrefsEditor/Runtime.meta | 8 + .../Runtime/PlayerPrefsUtility.cs | 393 ++++++ .../Runtime/PlayerPrefsUtility.cs.meta | 12 + .../Runtime/SimpleEncryption.cs | 167 +++ .../Runtime/SimpleEncryption.cs.meta | 12 + 14 files changed, 2917 insertions(+) create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Runtime.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs.meta create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs create mode 100644 Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs.meta diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor.meta b/Assets/TEngine/Editor/PlayerPrefsEditor.meta new file mode 100644 index 00000000..a376f802 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d25b49befa8d1a44ab78688adedbdbb2 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor.meta new file mode 100644 index 00000000..3057e3c6 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: cb6640d50acc3284b8f74f96f2bd2164 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs new file mode 100644 index 00000000..acd9931b --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs @@ -0,0 +1,42 @@ +using UnityEditor; +using UnityEngine; + +namespace Sabresaurus.PlayerPrefsEditor +{ + public class ImportPlayerPrefsWizard : ScriptableWizard + { + // Company and product name for importing PlayerPrefs from other projects + [SerializeField] string importCompanyName = ""; + [SerializeField] string importProductName = ""; + + private void OnEnable() + { + importCompanyName = PlayerSettings.companyName; + importProductName = PlayerSettings.productName; + } + + private void OnInspectorUpdate() + { + if (Resources.FindObjectsOfTypeAll(typeof(PlayerPrefsEditor)).Length == 0) + { + Close(); + } + } + + protected override bool DrawWizardGUI() + { + GUILayout.Label("Import PlayerPrefs from another project, also useful if you change product or company name", EditorStyles.wordWrappedLabel); + EditorGUILayout.Separator(); + bool v = base.DrawWizardGUI(); + return v; + } + + private void OnWizardCreate() + { + if (Resources.FindObjectsOfTypeAll(typeof(PlayerPrefsEditor)).Length >= 1) + { + ((PlayerPrefsEditor)Resources.FindObjectsOfTypeAll(typeof(PlayerPrefsEditor))[0]).Import(importCompanyName, importProductName); + } + } + } +} diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs.meta new file mode 100644 index 00000000..4aa0fad5 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/ImportPlayerPrefsWizard.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c6b3f7ec70c6748ca9e094873a90d5e4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac.meta new file mode 100644 index 00000000..4facaeb2 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 5c6e4502510d84cbdb83df6f3d1e83bd +folderAsset: yes +timeCreated: 1428611074 +licenseType: Free +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs new file mode 100644 index 00000000..5e04f8a2 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs @@ -0,0 +1,966 @@ +// +// PlistCS Property List (plist) serialization and parsing library. +// +// https://github.com/animetrics/PlistCS +// +// Copyright (c) 2011 Animetrics Inc. (marc@animetrics.com) +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + + +// Sabresaurus Note: parseBinaryReal has been modified from its state, please see the method's code for details + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Xml; + +namespace Sabresaurus.PlayerPrefsEditor +{ + public static class Plist + { + private static List offsetTable = new List(); + private static List objectTable = new List(); + private static int refCount; + private static int objRefSize; + private static int offsetByteSize; + private static long offsetTableOffset; + + #region Public Functions + + public static object readPlist(string path) + { + using (FileStream f = new FileStream(path, FileMode.Open, FileAccess.Read)) + { + return readPlist(f, plistType.Auto); + } + } + + public static object readPlistSource(string source) + { + return readPlist(System.Text.Encoding.UTF8.GetBytes(source)); + } + + public static object readPlist(byte[] data) + { + return readPlist(new MemoryStream(data), plistType.Auto); + } + + public static plistType getPlistType(Stream stream) + { + byte[] magicHeader = new byte[8]; + stream.Read(magicHeader, 0, 8); + + if (BitConverter.ToInt64(magicHeader, 0) == 3472403351741427810) + { + return plistType.Binary; + } + else + { + return plistType.Xml; + } + } + + public static object readPlist(Stream stream, plistType type) + { + if (type == plistType.Auto) + { + type = getPlistType(stream); + stream.Seek(0, SeekOrigin.Begin); + } + + if (type == plistType.Binary) + { + using (BinaryReader reader = new BinaryReader(stream)) + { + byte[] data = reader.ReadBytes((int)reader.BaseStream.Length); + return readBinary(data); + } + } + else + { + XmlDocument xml = new XmlDocument(); + xml.XmlResolver = null; + xml.Load(stream); + return readXml(xml); + } + } + + public static void writeXml(object value, string path) + { + using (StreamWriter writer = new StreamWriter(path)) + { + writer.Write(writeXml(value)); + } + } + + public static void writeXml(object value, Stream stream) + { + using (StreamWriter writer = new StreamWriter(stream)) + { + writer.Write(writeXml(value)); + } + } + + public static string writeXml(object value) + { + using (MemoryStream ms = new MemoryStream()) + { + XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); + xmlWriterSettings.Encoding = new System.Text.UTF8Encoding(false); + xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document; + xmlWriterSettings.Indent = true; + + using (XmlWriter xmlWriter = XmlWriter.Create(ms, xmlWriterSettings)) + { + xmlWriter.WriteStartDocument(); + //xmlWriter.WriteComment("DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" " + "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\""); + xmlWriter.WriteDocType("plist", "-//Apple Computer//DTD PLIST 1.0//EN", "http://www.apple.com/DTDs/PropertyList-1.0.dtd", null); + xmlWriter.WriteStartElement("plist"); + xmlWriter.WriteAttributeString("version", "1.0"); + compose(value, xmlWriter); + xmlWriter.WriteEndElement(); + xmlWriter.WriteEndDocument(); + xmlWriter.Flush(); + xmlWriter.Close(); + return System.Text.Encoding.UTF8.GetString(ms.ToArray()); + } + } + } + + public static void writeBinary(object value, string path) + { + using (BinaryWriter writer = new BinaryWriter(new FileStream(path, FileMode.Create))) + { + writer.Write(writeBinary(value)); + } + } + + public static void writeBinary(object value, Stream stream) + { + using (BinaryWriter writer = new BinaryWriter(stream)) + { + writer.Write(writeBinary(value)); + } + } + + public static byte[] writeBinary(object value) + { + offsetTable.Clear(); + objectTable.Clear(); + refCount = 0; + objRefSize = 0; + offsetByteSize = 0; + offsetTableOffset = 0; + + //Do not count the root node, subtract by 1 + int totalRefs = countObject(value) - 1; + + refCount = totalRefs; + + objRefSize = RegulateNullBytes(BitConverter.GetBytes(refCount)).Length; + + composeBinary(value); + + writeBinaryString("bplist00", false); + + offsetTableOffset = (long)objectTable.Count; + + offsetTable.Add(objectTable.Count - 8); + + offsetByteSize = RegulateNullBytes(BitConverter.GetBytes(offsetTable[offsetTable.Count - 1])).Length; + + List offsetBytes = new List(); + + offsetTable.Reverse(); + + for (int i = 0; i < offsetTable.Count; i++) + { + offsetTable[i] = objectTable.Count - offsetTable[i]; + byte[] buffer = RegulateNullBytes(BitConverter.GetBytes(offsetTable[i]), offsetByteSize); + Array.Reverse(buffer); + offsetBytes.AddRange(buffer); + } + + objectTable.AddRange(offsetBytes); + + objectTable.AddRange(new byte[6]); + objectTable.Add(Convert.ToByte(offsetByteSize)); + objectTable.Add(Convert.ToByte(objRefSize)); + + var a = BitConverter.GetBytes((long)totalRefs + 1); + Array.Reverse(a); + objectTable.AddRange(a); + + objectTable.AddRange(BitConverter.GetBytes((long)0)); + a = BitConverter.GetBytes(offsetTableOffset); + Array.Reverse(a); + objectTable.AddRange(a); + + return objectTable.ToArray(); + } + + #endregion + + #region Private Functions + + private static object readXml(XmlDocument xml) + { + XmlNode rootNode = xml.DocumentElement.ChildNodes[0]; + return parse(rootNode); + } + + private static object readBinary(byte[] data) + { + offsetTable.Clear(); + List offsetTableBytes = new List(); + objectTable.Clear(); + refCount = 0; + objRefSize = 0; + offsetByteSize = 0; + offsetTableOffset = 0; + + List bList = new List(data); + + List trailer = bList.GetRange(bList.Count - 32, 32); + + parseTrailer(trailer); + + objectTable = bList.GetRange(0, (int)offsetTableOffset); + + offsetTableBytes = bList.GetRange((int)offsetTableOffset, bList.Count - (int)offsetTableOffset - 32); + + parseOffsetTable(offsetTableBytes); + + return parseBinary(0); + } + + private static Dictionary parseDictionary(XmlNode node) + { + XmlNodeList children = node.ChildNodes; + if (children.Count % 2 != 0) + { + throw new DataMisalignedException("Dictionary elements must have an even number of child nodes"); + } + + Dictionary dict = new Dictionary(); + + for (int i = 0; i < children.Count; i += 2) + { + XmlNode keynode = children[i]; + XmlNode valnode = children[i + 1]; + + if (keynode.Name != "key") + { + throw new ApplicationException("expected a key node"); + } + + object result = parse(valnode); + + if (result != null) + { + dict.Add(keynode.InnerText, result); + } + } + + return dict; + } + + private static List parseArray(XmlNode node) + { + List array = new List(); + + foreach (XmlNode child in node.ChildNodes) + { + object result = parse(child); + if (result != null) + { + array.Add(result); + } + } + + return array; + } + + private static void composeArray(List value, XmlWriter writer) + { + writer.WriteStartElement("array"); + foreach (object obj in value) + { + compose(obj, writer); + } + writer.WriteEndElement(); + } + + private static object parse(XmlNode node) + { + switch (node.Name) + { + case "dict": + return parseDictionary(node); + case "array": + return parseArray(node); + case "string": + return node.InnerText; + case "integer": + // int result; + //int.TryParse(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo, out result); + return Convert.ToInt32(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo); + case "real": + return Convert.ToDouble(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo); + case "false": + return false; + case "true": + return true; + case "null": + return null; + case "date": + return XmlConvert.ToDateTime(node.InnerText, XmlDateTimeSerializationMode.Utc); + case "data": + return Convert.FromBase64String(node.InnerText); + } + + throw new ApplicationException(String.Format("Plist Node `{0}' is not supported", node.Name)); + } + + private static void compose(object value, XmlWriter writer) + { + + if (value == null || value is string) + { + writer.WriteElementString("string", value as string); + } + else if (value is int || value is long) + { + writer.WriteElementString("integer", ((int)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo)); + } + else if (value is System.Collections.Generic.Dictionary || + value.GetType().ToString().StartsWith("System.Collections.Generic.Dictionary`2[System.String")) + { + //Convert to Dictionary + Dictionary dic = value as Dictionary; + if (dic == null) + { + dic = new Dictionary(); + IDictionary idic = (IDictionary)value; + foreach (var key in idic.Keys) + { + dic.Add(key.ToString(), idic[key]); + } + } + writeDictionaryValues(dic, writer); + } + else if (value is List) + { + composeArray((List)value, writer); + } + else if (value is byte[]) + { + writer.WriteElementString("data", Convert.ToBase64String((Byte[])value)); + } + else if (value is float || value is double) + { + writer.WriteElementString("real", ((double)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo)); + } + else if (value is DateTime) + { + DateTime time = (DateTime)value; + string theString = XmlConvert.ToString(time, XmlDateTimeSerializationMode.Utc); + writer.WriteElementString("date", theString);//, "yyyy-MM-ddTHH:mm:ssZ")); + } + else if (value is bool) + { + writer.WriteElementString(value.ToString().ToLower(), ""); + } + else + { + throw new Exception(String.Format("Value type '{0}' is unhandled", value.GetType().ToString())); + } + } + + private static void writeDictionaryValues(Dictionary dictionary, XmlWriter writer) + { + writer.WriteStartElement("dict"); + foreach (string key in dictionary.Keys) + { + object value = dictionary[key]; + writer.WriteElementString("key", key); + compose(value, writer); + } + writer.WriteEndElement(); + } + + private static int countObject(object value) + { + int count = 0; + switch (value.GetType().ToString()) + { + case "System.Collections.Generic.Dictionary`2[System.String,System.Object]": + Dictionary dict = (Dictionary)value; + foreach (string key in dict.Keys) + { + count += countObject(dict[key]); + } + count += dict.Keys.Count; + count++; + break; + case "System.Collections.Generic.List`1[System.Object]": + List list = (List)value; + foreach (object obj in list) + { + count += countObject(obj); + } + count++; + break; + default: + count++; + break; + } + return count; + } + + private static byte[] writeBinaryDictionary(Dictionary dictionary) + { + List buffer = new List(); + List header = new List(); + List refs = new List(); + for (int i = dictionary.Count - 1; i >= 0; i--) + { + var o = new object[dictionary.Count]; + dictionary.Values.CopyTo(o, 0); + composeBinary(o[i]); + offsetTable.Add(objectTable.Count); + refs.Add(refCount); + refCount--; + } + for (int i = dictionary.Count - 1; i >= 0; i--) + { + var o = new string[dictionary.Count]; + dictionary.Keys.CopyTo(o, 0); + composeBinary(o[i]);//); + offsetTable.Add(objectTable.Count); + refs.Add(refCount); + refCount--; + } + + if (dictionary.Count < 15) + { + header.Add(Convert.ToByte(0xD0 | Convert.ToByte(dictionary.Count))); + } + else + { + header.Add(0xD0 | 0xf); + header.AddRange(writeBinaryInteger(dictionary.Count, false)); + } + + + foreach (int val in refs) + { + byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize); + Array.Reverse(refBuffer); + buffer.InsertRange(0, refBuffer); + } + + buffer.InsertRange(0, header); + + + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] composeBinaryArray(List objects) + { + List buffer = new List(); + List header = new List(); + List refs = new List(); + + for (int i = objects.Count - 1; i >= 0; i--) + { + composeBinary(objects[i]); + offsetTable.Add(objectTable.Count); + refs.Add(refCount); + refCount--; + } + + if (objects.Count < 15) + { + header.Add(Convert.ToByte(0xA0 | Convert.ToByte(objects.Count))); + } + else + { + header.Add(0xA0 | 0xf); + header.AddRange(writeBinaryInteger(objects.Count, false)); + } + + foreach (int val in refs) + { + byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize); + Array.Reverse(refBuffer); + buffer.InsertRange(0, refBuffer); + } + + buffer.InsertRange(0, header); + + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] composeBinary(object obj) + { + byte[] value; + switch (obj.GetType().ToString()) + { + case "System.Collections.Generic.Dictionary`2[System.String,System.Object]": + value = writeBinaryDictionary((Dictionary)obj); + return value; + + case "System.Collections.Generic.List`1[System.Object]": + value = composeBinaryArray((List)obj); + return value; + + case "System.Byte[]": + value = writeBinaryByteArray((byte[])obj); + return value; + + case "System.Double": + value = writeBinaryDouble((double)obj); + return value; + + case "System.Int32": + value = writeBinaryInteger((int)obj, true); + return value; + + case "System.String": + value = writeBinaryString((string)obj, true); + return value; + + case "System.DateTime": + value = writeBinaryDate((DateTime)obj); + return value; + + case "System.Boolean": + value = writeBinaryBool((bool)obj); + return value; + + default: + return new byte[0]; + } + } + + public static byte[] writeBinaryDate(DateTime obj) + { + List buffer = new List(RegulateNullBytes(BitConverter.GetBytes(PlistDateConverter.ConvertToAppleTimeStamp(obj)), 8)); + buffer.Reverse(); + buffer.Insert(0, 0x33); + objectTable.InsertRange(0, buffer); + return buffer.ToArray(); + } + + public static byte[] writeBinaryBool(bool obj) + { + List buffer = new List(new byte[1] { (bool)obj ? (byte)9 : (byte)8 }); + objectTable.InsertRange(0, buffer); + return buffer.ToArray(); + } + + private static byte[] writeBinaryInteger(int value, bool write) + { + List buffer = new List(BitConverter.GetBytes((long)value)); + buffer = new List(RegulateNullBytes(buffer.ToArray())); + while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2))) + buffer.Add(0); + int header = 0x10 | (int)(Math.Log(buffer.Count) / Math.Log(2)); + + buffer.Reverse(); + + buffer.Insert(0, Convert.ToByte(header)); + + if (write) + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] writeBinaryDouble(double value) + { + List buffer = new List(RegulateNullBytes(BitConverter.GetBytes(value), 4)); + while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2))) + buffer.Add(0); + int header = 0x20 | (int)(Math.Log(buffer.Count) / Math.Log(2)); + + buffer.Reverse(); + + buffer.Insert(0, Convert.ToByte(header)); + + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] writeBinaryByteArray(byte[] value) + { + List buffer = new List(value); + List header = new List(); + if (value.Length < 15) + { + header.Add(Convert.ToByte(0x40 | Convert.ToByte(value.Length))); + } + else + { + header.Add(0x40 | 0xf); + header.AddRange(writeBinaryInteger(buffer.Count, false)); + } + + buffer.InsertRange(0, header); + + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] writeBinaryString(string value, bool head) + { + List buffer = new List(); + List header = new List(); + foreach (char chr in value.ToCharArray()) + buffer.Add(Convert.ToByte(chr)); + + if (head) + { + if (value.Length < 15) + { + header.Add(Convert.ToByte(0x50 | Convert.ToByte(value.Length))); + } + else + { + header.Add(0x50 | 0xf); + header.AddRange(writeBinaryInteger(buffer.Count, false)); + } + } + + buffer.InsertRange(0, header); + + objectTable.InsertRange(0, buffer); + + return buffer.ToArray(); + } + + private static byte[] RegulateNullBytes(byte[] value) + { + return RegulateNullBytes(value, 1); + } + + private static byte[] RegulateNullBytes(byte[] value, int minBytes) + { + Array.Reverse(value); + List bytes = new List(value); + for (int i = 0; i < bytes.Count; i++) + { + if (bytes[i] == 0 && bytes.Count > minBytes) + { + bytes.Remove(bytes[i]); + i--; + } + else + break; + } + + if (bytes.Count < minBytes) + { + int dist = minBytes - bytes.Count; + for (int i = 0; i < dist; i++) + bytes.Insert(0, 0); + } + + value = bytes.ToArray(); + Array.Reverse(value); + return value; + } + + private static void parseTrailer(List trailer) + { + offsetByteSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(6, 1).ToArray(), 4), 0); + objRefSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(7, 1).ToArray(), 4), 0); + byte[] refCountBytes = trailer.GetRange(12, 4).ToArray(); + Array.Reverse(refCountBytes); + refCount = BitConverter.ToInt32(refCountBytes, 0); + byte[] offsetTableOffsetBytes = trailer.GetRange(24, 8).ToArray(); + Array.Reverse(offsetTableOffsetBytes); + offsetTableOffset = BitConverter.ToInt64(offsetTableOffsetBytes, 0); + } + + private static void parseOffsetTable(List offsetTableBytes) + { + for (int i = 0; i < offsetTableBytes.Count; i += offsetByteSize) + { + byte[] buffer = offsetTableBytes.GetRange(i, offsetByteSize).ToArray(); + Array.Reverse(buffer); + offsetTable.Add(BitConverter.ToInt32(RegulateNullBytes(buffer, 4), 0)); + } + } + + private static object parseBinaryDictionary(int objRef) + { + Dictionary buffer = new Dictionary(); + List refs = new List(); + int refCount = 0; + + int refStartPosition; + refCount = getCount(offsetTable[objRef], out refStartPosition); + + + if (refCount < 15) + refStartPosition = offsetTable[objRef] + 1; + else + refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length; + + for (int i = refStartPosition; i < refStartPosition + refCount * 2 * objRefSize; i += objRefSize) + { + byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray(); + Array.Reverse(refBuffer); + refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0)); + } + + for (int i = 0; i < refCount; i++) + { + buffer.Add((string)parseBinary(refs[i]), parseBinary(refs[i + refCount])); + } + + return buffer; + } + + private static object parseBinaryArray(int objRef) + { + List buffer = new List(); + List refs = new List(); + int refCount = 0; + + int refStartPosition; + refCount = getCount(offsetTable[objRef], out refStartPosition); + + + if (refCount < 15) + refStartPosition = offsetTable[objRef] + 1; + else + //The following integer has a header aswell so we increase the refStartPosition by two to account for that. + refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length; + + for (int i = refStartPosition; i < refStartPosition + refCount * objRefSize; i += objRefSize) + { + byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray(); + Array.Reverse(refBuffer); + refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0)); + } + + for (int i = 0; i < refCount; i++) + { + buffer.Add(parseBinary(refs[i])); + } + + return buffer; + } + + private static int getCount(int bytePosition, out int newBytePosition) + { + byte headerByte = objectTable[bytePosition]; + byte headerByteTrail = Convert.ToByte(headerByte & 0xf); + int count; + if (headerByteTrail < 15) + { + count = headerByteTrail; + newBytePosition = bytePosition + 1; + } + else + count = (int)parseBinaryInt(bytePosition + 1, out newBytePosition); + return count; + } + + private static object parseBinary(int objRef) + { + byte header = objectTable[offsetTable[objRef]]; + switch (header & 0xF0) + { + case 0: + { + //If the byte is + //0 return null + //9 return true + //8 return false + return (objectTable[offsetTable[objRef]] == 0) ? (object)null : ((objectTable[offsetTable[objRef]] == 9) ? true : false); + } + case 0x10: + { + return parseBinaryInt(offsetTable[objRef]); + } + case 0x20: + { + return parseBinaryReal(offsetTable[objRef]); + } + case 0x30: + { + return parseBinaryDate(offsetTable[objRef]); + } + case 0x40: + { + return parseBinaryByteArray(offsetTable[objRef]); + } + case 0x50://String ASCII + { + return parseBinaryAsciiString(offsetTable[objRef]); + } + case 0x60://String Unicode + { + return parseBinaryUnicodeString(offsetTable[objRef]); + } + case 0xD0: + { + return parseBinaryDictionary(objRef); + } + case 0xA0: + { + return parseBinaryArray(objRef); + } + } + throw new Exception("This type is not supported"); + } + + public static object parseBinaryDate(int headerPosition) + { + byte[] buffer = objectTable.GetRange(headerPosition + 1, 8).ToArray(); + Array.Reverse(buffer); + double appleTime = BitConverter.ToDouble(buffer, 0); + DateTime result = PlistDateConverter.ConvertFromAppleTimeStamp(appleTime); + return result; + } + + private static object parseBinaryInt(int headerPosition) + { + int output; + return parseBinaryInt(headerPosition, out output); + } + + private static object parseBinaryInt(int headerPosition, out int newHeaderPosition) + { + byte header = objectTable[headerPosition]; + int byteCount = (int)Math.Pow(2, header & 0xf); + byte[] buffer = objectTable.GetRange(headerPosition + 1, byteCount).ToArray(); + Array.Reverse(buffer); + //Add one to account for the header byte + newHeaderPosition = headerPosition + byteCount + 1; + return BitConverter.ToInt32(RegulateNullBytes(buffer, 4), 0); + } + + private static object parseBinaryReal(int headerPosition) + { + byte header = objectTable[headerPosition]; + int byteCount = (int)Math.Pow(2, header & 0xf); + byte[] buffer = objectTable.GetRange(headerPosition + 1, byteCount).ToArray(); + Array.Reverse(buffer); + + // Sabresaurus Note: This wasn't producing the right results with doubles, needed singles anyway, so I + // added this line. (original line is commented out) + return BitConverter.ToSingle(buffer, 0); + // return BitConverter.ToDouble(RegulateNullBytes(buffer, 8), 0); + } + + private static object parseBinaryAsciiString(int headerPosition) + { + int charStartPosition; + int charCount = getCount(headerPosition, out charStartPosition); + + var buffer = objectTable.GetRange(charStartPosition, charCount); + return buffer.Count > 0 ? Encoding.ASCII.GetString(buffer.ToArray()) : string.Empty; + } + + private static object parseBinaryUnicodeString(int headerPosition) + { + int charStartPosition; + int charCount = getCount(headerPosition, out charStartPosition); + charCount = charCount * 2; + + byte[] buffer = new byte[charCount]; + byte one, two; + + for (int i = 0; i < charCount; i += 2) + { + one = objectTable.GetRange(charStartPosition + i, 1)[0]; + two = objectTable.GetRange(charStartPosition + i + 1, 1)[0]; + + if (BitConverter.IsLittleEndian) + { + buffer[i] = two; + buffer[i + 1] = one; + } + else + { + buffer[i] = one; + buffer[i + 1] = two; + } + } + + return Encoding.Unicode.GetString(buffer); + } + + private static object parseBinaryByteArray(int headerPosition) + { + int byteStartPosition; + int byteCount = getCount(headerPosition, out byteStartPosition); + return objectTable.GetRange(byteStartPosition, byteCount).ToArray(); + } + + #endregion + } + + public enum plistType + { + Auto, Binary, Xml + } + + public static class PlistDateConverter + { + public static long timeDifference = 978307200; + + public static long GetAppleTime(long unixTime) + { + return unixTime - timeDifference; + } + + public static long GetUnixTime(long appleTime) + { + return appleTime + timeDifference; + } + + public static DateTime ConvertFromAppleTimeStamp(double timestamp) + { + DateTime origin = new DateTime(2001, 1, 1, 0, 0, 0, 0); + return origin.AddSeconds(timestamp); + } + + public static double ConvertToAppleTimeStamp(DateTime date) + { + DateTime begin = new DateTime(2001, 1, 1, 0, 0, 0, 0); + TimeSpan diff = date - begin; + return Math.Floor(diff.TotalSeconds); + } + } +} diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs.meta new file mode 100644 index 00000000..2b07c61b --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/Mac/Plist.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 13682d2806448491fa039347c891521e +timeCreated: 1428611074 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs new file mode 100644 index 00000000..bc998ebc --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs @@ -0,0 +1,1257 @@ +using System; +using System.Collections.Generic; +using System.IO; +using UnityEditor; +#if UNITY_5_6_OR_NEWER +using UnityEditor.IMGUI.Controls; +#endif +using UnityEngine; +using Sabresaurus.PlayerPrefsUtilities; + +namespace Sabresaurus.PlayerPrefsEditor +{ + public class PlayerPrefsEditor : EditorWindow + { + private static System.Text.Encoding encoding = new System.Text.UTF8Encoding(); + + // Represents a PlayerPref key-value record + private struct PlayerPrefPair + { + public string Key + { + get; + set; + } + + public object Value + { + get; + set; + } + } + + readonly DateTime MISSING_DATETIME = new DateTime(1601, 1, 1); + + // If True display EditorPrefs instead of PlayerPrefs + bool showEditorPrefs = false; + + // Natively PlayerPrefs can be one of these three types + enum PlayerPrefType { Float = 0, Int, String, Bool }; + + // The actual cached store of PlayerPref records fetched from registry or plist + List deserializedPlayerPrefs = new List(); + + // When a search is in effect the search results are cached in this list + List filteredPlayerPrefs = new List(); + + // Track last successful deserialisation to prevent doing this too often. On OSX this uses the PlayerPrefs file + // last modified time, on Windows we just poll repeatedly and use this to prevent polling again too soon. + DateTime? lastDeserialization = null; + + // The view position of the PlayerPrefs scroll view + Vector2 scrollPosition; + + // The scroll position from last frame (used with scrollPosition to detect user scrolling) + Vector2 lastScrollPosition; + + // Prevent OnInspector() forcing a repaint every time it's called + int inspectorUpdateFrame = 0; + + // Automatically attempt to decrypt keys and values that are detected as encrypted + bool automaticDecryption = true; + + // Filter the keys by search + string searchFilter = string.Empty; + + // Because of some issues with deleting from OnGUI, we defer it to OnInspectorUpdate() instead + string keyQueuedForDeletion = null; + + #region Adding New PlayerPref + // This is the current type of PlayerPref that the user is about to create + PlayerPrefType newEntryType = PlayerPrefType.String; + + // Whether the PlayerPref should be encrypted + bool newEntryIsEncrypted = false; + + // The identifier of the new PlayerPref + string newEntryKey = ""; + + // Value of the PlayerPref about to be created (must be tracked differently for each type) + float newEntryValueFloat = 0; + int newEntryValueInt = 0; + bool newEntryValueBool = false; + string newEntryValueString = ""; + #endregion + +#if UNITY_5_6_OR_NEWER + SearchField searchField; +#endif + + [MenuItem("Window/PlayerPrefs Editor")] + private static void Init() + { + // Get existing open window or if none, make a new one: + PlayerPrefsEditor editor = (PlayerPrefsEditor)GetWindow(typeof(PlayerPrefsEditor), false, "Prefs Editor"); + + // Require the editor window to be at least 300 pixels wide + Vector2 minSize = editor.minSize; + minSize.x = 230; + editor.minSize = minSize; + } + + private static string GetMacOSEditorPrefsPath() + { +#if UNITY_2017_4_OR_NEWER + // From Unity Docs: On macOS, EditorPrefs are stored in ~/Library/Preferences/com.unity3d.UnityEditor5.x.plist + // https://docs.unity3d.com/2017.4/Documentation/ScriptReference/EditorPrefs.html + string fileName = "com.unity3d.UnityEditor5.x.plist"; +#else + // From Unity Docs: On macOS, EditorPrefs are stored in ~/Library/Preferences/com.unity3d.UnityEditor.plist. + // https://docs.unity3d.com/2017.3/Documentation/ScriptReference/EditorPrefs.html + string fileName = "com.unity3d.UnityEditor.plist"; +#endif + // Construct the fully qualified path + string editorPrefsPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library/Preferences"), fileName); + return editorPrefsPath; + } + + private void OnEnable() + { + searchField = new SearchField(); + + deserializedPlayerPrefs = new List(RetrieveSavedPrefs(PlayerSettings.companyName, PlayerSettings.productName)); + UpdateSearch(); + } + + private void DeleteAll() + { + if (showEditorPrefs) + { + EditorPrefs.DeleteAll(); + } + else + { + PlayerPrefs.DeleteAll(); + } + } + + private void DeleteKey(string key) + { + if (showEditorPrefs) + { + EditorPrefs.DeleteKey(key); + } + else + { + PlayerPrefs.DeleteKey(key); + } + } + + private int GetInt(string key, int defaultValue = 0) + { + if (showEditorPrefs) + { + return EditorPrefs.GetInt(key, defaultValue); + } + else + { + return PlayerPrefs.GetInt(key, defaultValue); + } + } + + private float GetFloat(string key, float defaultValue = 0.0f) + { + if (showEditorPrefs) + { + return EditorPrefs.GetFloat(key, defaultValue); + } + else + { + return PlayerPrefs.GetFloat(key, defaultValue); + } + } + + private string GetString(string key, string defaultValue = "") + { + if (showEditorPrefs) + { + return EditorPrefs.GetString(key, defaultValue); + } + else + { + return PlayerPrefs.GetString(key, defaultValue); + } + } + + private bool GetBool(string key, bool defaultValue = false) + { + if (showEditorPrefs) + { + return EditorPrefs.GetBool(key, defaultValue); + } + else + { + throw new NotSupportedException("PlayerPrefs interface does not natively support bools"); + } + } + + private void SetInt(string key, int value) + { + if (showEditorPrefs) + { + EditorPrefs.SetInt(key, value); + } + else + { + PlayerPrefs.SetInt(key, value); + } + } + + private void SetFloat(string key, float value) + { + if (showEditorPrefs) + { + EditorPrefs.SetFloat(key, value); + } + else + { + PlayerPrefs.SetFloat(key, value); + } + } + + private void SetString(string key, string value) + { + if (showEditorPrefs) + { + EditorPrefs.SetString(key, value); + } + else + { + PlayerPrefs.SetString(key, value); + } + } + + private void SetBool(string key, bool value) + { + if (showEditorPrefs) + { + EditorPrefs.SetBool(key, value); + } + else + { + throw new NotSupportedException("PlayerPrefs interface does not natively support bools"); + } + } + + private void Save() + { + if (showEditorPrefs) + { + // No Save() method in EditorPrefs + } + else + { + PlayerPrefs.Save(); + } + } + + /// + /// This returns an array of the stored PlayerPrefs from the file system (OSX) or registry (Windows), to allow + /// us to to look up what's actually in the PlayerPrefs. This is used as a kind of lookup table. + /// + private PlayerPrefPair[] RetrieveSavedPrefs(string companyName, string productName) + { + if (Application.platform == RuntimePlatform.OSXEditor) + { + string playerPrefsPath; + + if (showEditorPrefs) + { + playerPrefsPath = GetMacOSEditorPrefsPath(); + } + else + { + // From Unity Docs: On Mac OS X PlayerPrefs are stored in ~/Library/Preferences folder, in a file named unity.[company name].[product name].plist, where company and product names are the names set up in Project Settings. The same .plist file is used for both Projects run in the Editor and standalone players. + + // Construct the plist filename from the project's settings + string plistFilename = string.Format("unity.{0}.{1}.plist", companyName, productName); + // Now construct the fully qualified path + playerPrefsPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library/Preferences"), plistFilename); + } + + // Parse the PlayerPrefs file if it exists + if (File.Exists(playerPrefsPath)) + { + // Parse the plist then cast it to a Dictionary + object plist = Plist.readPlist(playerPrefsPath); + + Dictionary parsed = plist as Dictionary; + + // Convert the dictionary data into an array of PlayerPrefPairs + List tempPlayerPrefs = new List(parsed.Count); + foreach (KeyValuePair pair in parsed) + { + if (pair.Value.GetType() == typeof(double)) + { + // Some float values may come back as double, so convert them back to floats + tempPlayerPrefs.Add(new PlayerPrefPair() { Key = pair.Key, Value = (float)(double)pair.Value }); + } + else if (pair.Value.GetType() == typeof(bool)) + { + // Unity PlayerPrefs API doesn't allow bools, so ignore them + } + else + { + tempPlayerPrefs.Add(new PlayerPrefPair() { Key = pair.Key, Value = pair.Value }); + } + } + // Return the results + return tempPlayerPrefs.ToArray(); + } + else + { + // No existing PlayerPrefs saved (which is valid), so just return an empty array + return new PlayerPrefPair[0]; + } + } + else if (Application.platform == RuntimePlatform.WindowsEditor) + { + Microsoft.Win32.RegistryKey registryKey; + + if (showEditorPrefs) + { + // Starting Unity 5.5 registry key has " 5.x" suffix: https://docs.unity3d.com/550/Documentation/ScriptReference/EditorPrefs.html + // Even though for some versions of Unity docs state that N.x suffix is used where N.x is the major version number, + // it's still " 5.x" suffix used for that cases which is probably bug in the docs. + // Note that starting 2019.2 docs have " 5.x" suffix: https://docs.unity3d.com/2019.2/Documentation/ScriptReference/EditorPrefs.html +#if UNITY_5_5_OR_NEWER + string subKeyPath = "Software\\Unity Technologies\\Unity Editor 5.x"; +#else + string subKeyPath = "Software\\Unity Technologies\\Unity Editor"; +#endif + + registryKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(subKeyPath); + } + else + { + // From Unity docs: On Windows, PlayerPrefs are stored in the registry under HKCU\Software\[company name]\[product name] key, where company and product names are the names set up in Project Settings. +#if UNITY_5_5_OR_NEWER + // From Unity 5.5 editor PlayerPrefs moved to a specific location + registryKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software\\Unity\\UnityEditor\\" + companyName + "\\" + productName); +#else + registryKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software\\" + companyName + "\\" + productName); +#endif + } + + // Parse the registry if the specified registryKey exists + if (registryKey != null) + { + // Get an array of what keys (registry value names) are stored + string[] valueNames = registryKey.GetValueNames(); + + // Create the array of the right size to take the saved PlayerPrefs + PlayerPrefPair[] tempPlayerPrefs = new PlayerPrefPair[valueNames.Length]; + + // Parse and convert the registry saved PlayerPrefs into our array + int i = 0; + foreach (string valueName in valueNames) + { + string key = valueName; + + // Remove the _h193410979 style suffix used on PlayerPref keys in Windows registry + int index = key.LastIndexOf("_"); + key = key.Remove(index, key.Length - index); + + // Get the value from the registry + object ambiguousValue = registryKey.GetValue(valueName); + + // Unfortunately floats will come back as an int (at least on 64 bit) because the float is stored as + // 64 bit but marked as 32 bit - which confuses the GetValue() method greatly! + if (ambiguousValue.GetType() == typeof(int)) + { + // If the PlayerPref is not actually an int then it must be a float, this will evaluate to true + // (impossible for it to be 0 and -1 at the same time) + if (GetInt(key, -1) == -1 && GetInt(key, 0) == 0) + { + // Fetch the float value from PlayerPrefs in memory + ambiguousValue = GetFloat(key); + } + else if (showEditorPrefs && (GetBool(key, true) != true || GetBool(key, false) != false)) + { + // If it reports a non default value as a bool, it's a bool not a string + ambiguousValue = GetBool(key); + } + } + else if (ambiguousValue.GetType() == typeof(byte[])) + { + // On Unity 5 a string may be stored as binary, so convert it back to a string + ambiguousValue = encoding.GetString((byte[])ambiguousValue).TrimEnd('\0'); + } + // Assign the key and value into the respective record in our output array + tempPlayerPrefs[i] = new PlayerPrefPair() { Key = key, Value = ambiguousValue }; + i++; + } + // Return the results + return tempPlayerPrefs; + } + else + { + // No existing PlayerPrefs saved (which is valid), so just return an empty array + return new PlayerPrefPair[0]; + } + } + else + { + throw new NotSupportedException("PlayerPrefsEditor doesn't support this Unity Editor platform"); + } + } + + private void UpdateSearch() + { + // Clear any existing cached search results + filteredPlayerPrefs.Clear(); + + // Don't attempt to find the search results if a search filter hasn't actually been supplied + if (string.IsNullOrEmpty(searchFilter)) + { + return; + } + + int entryCount = deserializedPlayerPrefs.Count; + + // Iterate through all the cached results and add any matches to filteredPlayerPrefs + for (int i = 0; i < entryCount; i++) + { + string fullKey = deserializedPlayerPrefs[i].Key; + string displayKey = fullKey; + + // Special case for encrypted keys in auto decrypt mode, search should use decrypted values + bool isEncryptedPair = PlayerPrefsUtility.IsEncryptedKey(deserializedPlayerPrefs[i].Key); + if (automaticDecryption && isEncryptedPair) + { + displayKey = PlayerPrefsUtility.DecryptKey(fullKey); + } + + // If the key contains the search filter (ToLower used on both parts to make this case insensitive) + if (displayKey.ToLower().Contains(searchFilter.ToLower())) + { + filteredPlayerPrefs.Add(deserializedPlayerPrefs[i]); + } + // Else check value + else if (deserializedPlayerPrefs[i].Value.ToString().ToLower().Contains(searchFilter.ToLower())) + { + filteredPlayerPrefs.Add(deserializedPlayerPrefs[i]); + } + } + } + + private void DrawTopBar() + { +#if UNITY_5_6_OR_NEWER + string newSearchFilter = searchField.OnGUI(searchFilter); + GUILayout.Space(4); +#else + + EditorGUILayout.BeginHorizontal(); + // Heading + GUILayout.Label("Search", GUILayout.MaxWidth(50)); + // Actual search box + string newSearchFilter = EditorGUILayout.TextField(searchFilter); + + EditorGUILayout.EndHorizontal(); +#endif + + // If the requested search filter has changed + if (newSearchFilter != searchFilter) + { + searchFilter = newSearchFilter; + // Trigger UpdateSearch to calculate new search results + UpdateSearch(); + } + + // Allow the user to toggle between editor and PlayerPrefs + int oldIndex = showEditorPrefs ? 1 : 0; + int newIndex = GUILayout.Toolbar(oldIndex, new string[] { "PlayerPrefs", "EditorPrefs" }); + + // Has the toggle changed? + if (newIndex != oldIndex) + { + // Reset + lastDeserialization = null; + showEditorPrefs = (newIndex == 1); + } + } + + private void DrawMainList() + { + // The bold table headings + EditorGUILayout.BeginHorizontal(); + GUILayout.Label("Key", EditorStyles.boldLabel); + GUILayout.Label("Value", EditorStyles.boldLabel); + GUILayout.Label("Type", EditorStyles.boldLabel, GUILayout.Width(37)); + GUILayout.Label("Del", EditorStyles.boldLabel, GUILayout.Width(25)); + EditorGUILayout.EndHorizontal(); + + // Create a GUIStyle that can be manipulated for the various text fields + GUIStyle textFieldStyle = new GUIStyle(GUI.skin.textField); + + // Could be dealing with either the full list or search results, so get the right list + List activePlayerPrefs = deserializedPlayerPrefs; + + if (!string.IsNullOrEmpty(searchFilter)) + { + activePlayerPrefs = filteredPlayerPrefs; + } + + // Cache the entry count + int entryCount = activePlayerPrefs.Count; + + // Record the last scroll position so we can calculate if the user has scrolled this frame + lastScrollPosition = scrollPosition; + + // Start the scrollable area + scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition); + // Ensure the scroll doesn't go below zero + if (scrollPosition.y < 0) + { + scrollPosition.y = 0; + } + + // The following code has been optimised so that rather than attempting to draw UI for every single PlayerPref + // it instead only draws the UI for those currently visible in the scroll view and pads above and below those + // results to maintain the right size using GUILayout.Space(). This enables us to work with thousands of + // PlayerPrefs without slowing the interface to a halt. + + // Fixed height of one of the rows in the table + float rowHeight = 18; + + // Determine how many rows are visible on screen. For simplicity, use Screen.height (the overhead is negligible) + int visibleCount = Mathf.CeilToInt(Screen.height / rowHeight); + + // Determine the index of the first PlayerPref that should be drawn as visible in the scrollable area + int firstShownIndex = Mathf.FloorToInt(scrollPosition.y / rowHeight); + + // Determine the bottom limit of the visible PlayerPrefs (last shown index + 1) + int shownIndexLimit = firstShownIndex + visibleCount; + + // If the actual number of PlayerPrefs is smaller than the caculated limit, reduce the limit to match + if (entryCount < shownIndexLimit) + { + shownIndexLimit = entryCount; + } + + // If the number of displayed PlayerPrefs is smaller than the number we can display (like we're at the end + // of the list) then move the starting index back to adjust + if (shownIndexLimit - firstShownIndex < visibleCount) + { + firstShownIndex -= visibleCount - (shownIndexLimit - firstShownIndex); + } + + // Can't have a negative index of a first shown PlayerPref, so clamp to 0 + if (firstShownIndex < 0) + { + firstShownIndex = 0; + } + + // Pad above the on screen results so that we're not wasting draw calls on invisible UI and the drawn player + // prefs end up in the same place in the list + GUILayout.Space(firstShownIndex * rowHeight); + + // For each of the on screen results + for (int i = firstShownIndex; i < shownIndexLimit; i++) + { + // Detect if it's an encrypted PlayerPref (these have key prefixes) + bool isEncryptedPair = PlayerPrefsUtility.IsEncryptedKey(activePlayerPrefs[i].Key); + + // Colour code encrypted PlayerPrefs blue + if (isEncryptedPair) + { + if (UsingProSkin) + { + textFieldStyle.normal.textColor = new Color(0.5f, 0.5f, 1); + textFieldStyle.focused.textColor = new Color(0.5f, 0.5f, 1); + } + else + { + textFieldStyle.normal.textColor = new Color(0, 0, 1); + textFieldStyle.focused.textColor = new Color(0, 0, 1); + } + } + else + { + // Normal PlayerPrefs are just black + textFieldStyle.normal.textColor = GUI.skin.textField.normal.textColor; + textFieldStyle.focused.textColor = GUI.skin.textField.focused.textColor; + } + + // The full key is the key that's actually stored in PlayerPrefs + string fullKey = activePlayerPrefs[i].Key; + + // Display key is used so in the case of encrypted keys, we display the decrypted version instead (in + // auto-decrypt mode). + string displayKey = fullKey; + + // Used for accessing the type information stored against the PlayerPref + object deserializedValue = activePlayerPrefs[i].Value; + + // Track whether the auto decrypt failed, so we can instead fallback to encrypted values and mark it red + bool failedAutoDecrypt = false; + + // If this is an encrypted play pref and we're attempting to decrypt them, try to decrypt it! + if (isEncryptedPair && automaticDecryption) + { + // This may throw exceptions (e.g. if private key changes), so wrap in a try-catch + try + { + deserializedValue = PlayerPrefsUtility.GetEncryptedValue(fullKey, (string)deserializedValue); + displayKey = PlayerPrefsUtility.DecryptKey(fullKey); + } + catch + { + // Change the colour to red to highlight the decrypt failed + textFieldStyle.normal.textColor = Color.red; + textFieldStyle.focused.textColor = Color.red; + + // Track that the auto decrypt failed, so we can prevent any editing + failedAutoDecrypt = true; + } + } + + EditorGUILayout.BeginHorizontal(); + + // The type of PlayerPref being stored (in auto decrypt mode this works with the decrypted values too) + Type valueType; + + // If it's an encrypted playerpref, we're automatically decrypting and it didn't fail the earlier + // auto decrypt test + if (isEncryptedPair && automaticDecryption && !failedAutoDecrypt) + { + // Get the encrypted string + string encryptedValue = GetString(fullKey); + // Set valueType appropiately based on which type identifier prefix the encrypted string starts with + if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_FLOAT_PREFIX)) + { + valueType = typeof(float); + } + else if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_INT_PREFIX)) + { + valueType = typeof(int); + } + else if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_BOOL_PREFIX)) + { + valueType = typeof(bool); + } + else if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_STRING_PREFIX) || string.IsNullOrEmpty(encryptedValue)) + { + // Special case here, empty encrypted values will also report as strings + valueType = typeof(string); + } + else + { + throw new InvalidOperationException("Could not decrypt item, no match found in known encrypted key prefixes"); + } + } + else + { + // Otherwise fallback to the type of the cached value (for non-encrypted values this will be + // correct). For encrypted values when not in auto-decrypt mode, this will return string type + valueType = deserializedValue.GetType(); + } + + // Display the PlayerPref key + EditorGUILayout.TextField(displayKey, textFieldStyle); + + // Value display and user editing + // If we're dealing with a float + if (valueType == typeof(float)) + { + float initialValue; + if (isEncryptedPair && automaticDecryption) + { + // Automatically decrypt the value if encrypted and in auto-decrypt mode + initialValue = PlayerPrefsUtility.GetEncryptedFloat(displayKey); + } + else + { + // Otherwise fetch the latest plain value from PlayerPrefs in memory + initialValue = GetFloat(fullKey); + } + + // Display the float editor field and get any changes in value + float newValue = EditorGUILayout.FloatField(initialValue, textFieldStyle); + + // If the value has changed + if (newValue != initialValue) + { + // Store the changed value in PlayerPrefs, encrypting if necessary + if (isEncryptedPair) + { + string encryptedValue = PlayerPrefsUtility.VALUE_FLOAT_PREFIX + SimpleEncryption.EncryptFloat(newValue); + SetString(fullKey, encryptedValue); + } + else + { + SetFloat(fullKey, newValue); + } + // Save PlayerPrefs + Save(); + } + // Display the PlayerPref type + GUILayout.Label("float", GUILayout.Width(37)); + } + else if (valueType == typeof(int)) // if we're dealing with an int + { + int initialValue; + if (isEncryptedPair && automaticDecryption) + { + // Automatically decrypt the value if encrypted and in auto-decrypt mode + initialValue = PlayerPrefsUtility.GetEncryptedInt(displayKey); + } + else + { + // Otherwise fetch the latest plain value from PlayerPrefs in memory + initialValue = GetInt(fullKey); + } + + // Display the int editor field and get any changes in value + int newValue = EditorGUILayout.IntField(initialValue, textFieldStyle); + + // If the value has changed + if (newValue != initialValue) + { + // Store the changed value in PlayerPrefs, encrypting if necessary + if (isEncryptedPair) + { + string encryptedValue = PlayerPrefsUtility.VALUE_INT_PREFIX + SimpleEncryption.EncryptInt(newValue); + SetString(fullKey, encryptedValue); + } + else + { + SetInt(fullKey, newValue); + } + // Save PlayerPrefs + Save(); + } + // Display the PlayerPref type + GUILayout.Label("int", GUILayout.Width(37)); + } + else if (valueType == typeof(bool)) // if we're dealing with a bool + { + bool initialValue; + if (isEncryptedPair && automaticDecryption) + { + // Automatically decrypt the value if encrypted and in auto-decrypt mode + initialValue = PlayerPrefsUtility.GetEncryptedBool(displayKey); + } + else + { + // Otherwise fetch the latest plain value from PlayerPrefs in memory + initialValue = GetBool(fullKey); + } + + // Display the bool toggle editor field and get any changes in value + bool newValue = EditorGUILayout.Toggle(initialValue); + + // If the value has changed + if (newValue != initialValue) + { + // Store the changed value in PlayerPrefs, encrypting if necessary + if (isEncryptedPair) + { + string encryptedValue = PlayerPrefsUtility.VALUE_BOOL_PREFIX + SimpleEncryption.EncryptBool(newValue); + SetString(fullKey, encryptedValue); + } + else + { + SetBool(fullKey, newValue); + } + // Save PlayerPrefs + Save(); + } + // Display the PlayerPref type + GUILayout.Label("bool", GUILayout.Width(37)); + } + else if (valueType == typeof(string)) // if we're dealing with a string + { + string initialValue; + if (isEncryptedPair && automaticDecryption && !failedAutoDecrypt) + { + // Automatically decrypt the value if encrypted and in auto-decrypt mode + initialValue = PlayerPrefsUtility.GetEncryptedString(displayKey); + } + else + { + // Otherwise fetch the latest plain value from PlayerPrefs in memory + initialValue = GetString(fullKey); + } + + // Display the text (string) editor field and get any changes in value + string newValue = EditorGUILayout.TextField(initialValue, textFieldStyle); + + // If the value has changed + if (newValue != initialValue && !failedAutoDecrypt) + { + // Store the changed value in PlayerPrefs, encrypting if necessary + if (isEncryptedPair) + { + string encryptedValue = PlayerPrefsUtility.VALUE_STRING_PREFIX + SimpleEncryption.EncryptString(newValue); + SetString(fullKey, encryptedValue); + } + else + { + SetString(fullKey, newValue); + } + // Save PlayerPrefs + Save(); + } + if (isEncryptedPair && !automaticDecryption && !string.IsNullOrEmpty(initialValue)) + { + // Because encrypted values when not in auto-decrypt mode are stored as string, determine their + // encrypted type and display that instead for these encrypted PlayerPrefs + PlayerPrefType playerPrefType = (PlayerPrefType)(int)char.GetNumericValue(initialValue[0]); + GUILayout.Label(playerPrefType.ToString().ToLower(), GUILayout.Width(37)); + } + else + { + // Display the PlayerPref type + GUILayout.Label("string", GUILayout.Width(37)); + } + } + + // Delete button + if (GUILayout.Button("X", GUILayout.Width(25))) + { + // Delete the key from PlayerPrefs + DeleteKey(fullKey); + // Tell Unity to Save PlayerPrefs + Save(); + // Delete the cached record so the list updates immediately + DeleteCachedRecord(fullKey); + } + EditorGUILayout.EndHorizontal(); + } + + // Calculate the padding at the bottom of the scroll view (because only visible PlayerPref rows are drawn) + float bottomPadding = (entryCount - shownIndexLimit) * rowHeight; + + // If the padding is positive, pad the bottom so that the layout and scroll view size is correct still + if (bottomPadding > 0) + { + GUILayout.Space(bottomPadding); + } + + EditorGUILayout.EndScrollView(); + + // Display the number of PlayerPrefs + GUILayout.Label("Entry Count: " + entryCount); + + Rect rect = GUILayoutUtility.GetLastRect(); + rect.height = 1; + rect.y -= 4; + EditorGUI.DrawRect(rect, new Color(0.5f, 0.5f, 0.5f, 0.5f)); + } + + private void DrawAddEntry() + { + // Create a GUIStyle that can be manipulated for the various text fields + GUIStyle textFieldStyle = new GUIStyle(GUI.skin.textField); + + // Create a space + EditorGUILayout.Space(); + + // Heading + GUILayout.Label(showEditorPrefs ? "Add EditorPref" : "Add PlayerPref", EditorStyles.boldLabel); + + // UI for whether the new PlayerPref is encrypted and what type it is + EditorGUILayout.BeginHorizontal(); + newEntryIsEncrypted = GUILayout.Toggle(newEntryIsEncrypted, "Encrypt"); + + if (showEditorPrefs) + { + newEntryType = (PlayerPrefType)GUILayout.Toolbar((int)newEntryType, new string[] { "float", "int", "string", "bool" }); + } + else + { + if (newEntryType == PlayerPrefType.Bool) + newEntryType = PlayerPrefType.String; + + newEntryType = (PlayerPrefType)GUILayout.Toolbar((int)newEntryType, new string[] { "float", "int", "string" }); + } + + EditorGUILayout.EndHorizontal(); + + // Key and Value headings + EditorGUILayout.BeginHorizontal(); + GUILayout.Label("Key", EditorStyles.boldLabel); + GUILayout.Label("Value", EditorStyles.boldLabel); + EditorGUILayout.EndHorizontal(); + + // If the new value will be encrypted tint the text boxes blue (in line with the display style for existing + // encrypted PlayerPrefs) + if (newEntryIsEncrypted) + { + if (UsingProSkin) + { + textFieldStyle.normal.textColor = new Color(0.5f, 0.5f, 1); + textFieldStyle.focused.textColor = new Color(0.5f, 0.5f, 1); + } + else + { + textFieldStyle.normal.textColor = new Color(0, 0, 1); + textFieldStyle.focused.textColor = new Color(0, 0, 1); + } + } + + EditorGUILayout.BeginHorizontal(); + + // Track the next control so we can detect key events in it + GUI.SetNextControlName("newEntryKey"); + // UI for the new key text box + newEntryKey = EditorGUILayout.TextField(newEntryKey, textFieldStyle); + + // Track the next control so we can detect key events in it + GUI.SetNextControlName("newEntryValue"); + + // Display the correct UI field editor based on what type of PlayerPref is being created + if (newEntryType == PlayerPrefType.Float) + { + newEntryValueFloat = EditorGUILayout.FloatField(newEntryValueFloat, textFieldStyle); + } + else if (newEntryType == PlayerPrefType.Int) + { + newEntryValueInt = EditorGUILayout.IntField(newEntryValueInt, textFieldStyle); + } + else if (newEntryType == PlayerPrefType.Bool) + { + newEntryValueBool = EditorGUILayout.Toggle(newEntryValueBool); + } + else + { + newEntryValueString = EditorGUILayout.TextField(newEntryValueString, textFieldStyle); + } + + // If the user hit enter while either the key or value fields were being edited + bool keyboardAddPressed = Event.current.isKey && Event.current.keyCode == KeyCode.Return && Event.current.type == EventType.KeyUp && (GUI.GetNameOfFocusedControl() == "newEntryKey" || GUI.GetNameOfFocusedControl() == "newEntryValue"); + + // If the user clicks the Add button or hits return (and there is a non-empty key), create the PlayerPref + if ((GUILayout.Button("Add", GUILayout.Width(40)) || keyboardAddPressed) && !string.IsNullOrEmpty(newEntryKey)) + { + // If the PlayerPref we're creating is encrypted + if (newEntryIsEncrypted) + { + // Encrypt the key + string encryptedKey = PlayerPrefsUtility.KEY_PREFIX + SimpleEncryption.EncryptString(newEntryKey); + + // Note: All encrypted values are stored as string + string encryptedValue; + + // Calculate the encrypted value + if (newEntryType == PlayerPrefType.Float) + { + encryptedValue = PlayerPrefsUtility.VALUE_FLOAT_PREFIX + SimpleEncryption.EncryptFloat(newEntryValueFloat); + } + else if (newEntryType == PlayerPrefType.Int) + { + encryptedValue = PlayerPrefsUtility.VALUE_INT_PREFIX + SimpleEncryption.EncryptInt(newEntryValueInt); + } + else if (newEntryType == PlayerPrefType.Bool) + { + encryptedValue = PlayerPrefsUtility.VALUE_BOOL_PREFIX + SimpleEncryption.EncryptBool(newEntryValueBool); + } + else + { + encryptedValue = PlayerPrefsUtility.VALUE_STRING_PREFIX + SimpleEncryption.EncryptString(newEntryValueString); + } + + // Record the new PlayerPref in PlayerPrefs + SetString(encryptedKey, encryptedValue); + + // Cache the addition + CacheRecord(encryptedKey, encryptedValue); + } + else + { + if (newEntryType == PlayerPrefType.Float) + { + // Record the new PlayerPref in PlayerPrefs + SetFloat(newEntryKey, newEntryValueFloat); + // Cache the addition + CacheRecord(newEntryKey, newEntryValueFloat); + } + else if (newEntryType == PlayerPrefType.Int) + { + // Record the new PlayerPref in PlayerPrefs + SetInt(newEntryKey, newEntryValueInt); + // Cache the addition + CacheRecord(newEntryKey, newEntryValueInt); + } + else if (newEntryType == PlayerPrefType.Bool) + { + // Record the new PlayerPref in PlayerPrefs + SetBool(newEntryKey, newEntryValueBool); + // Cache the addition + CacheRecord(newEntryKey, newEntryValueBool); + } + else + { + // Record the new PlayerPref in PlayerPrefs + SetString(newEntryKey, newEntryValueString); + // Cache the addition + CacheRecord(newEntryKey, newEntryValueString); + } + } + + // Tell Unity to save the PlayerPrefs + Save(); + + // Force a repaint since hitting the return key won't invalidate layout on its own + Repaint(); + + // Reset the values + newEntryKey = ""; + newEntryValueFloat = 0; + newEntryValueInt = 0; + newEntryValueString = ""; + + // Deselect + GUI.FocusControl(""); + } + + EditorGUILayout.EndHorizontal(); + } + + private void DrawBottomMenu() + { + EditorGUILayout.Space(); + + // UI for toggling automatic decryption on and off + automaticDecryption = EditorGUILayout.Toggle("Auto-Decryption", automaticDecryption); + + if (showEditorPrefs == false) + { + // Allow the user to import PlayerPrefs from another project (helpful when renaming product name) + if (GUILayout.Button("Import")) + { + ImportPlayerPrefsWizard wizard = ScriptableWizard.DisplayWizard("Import PlayerPrefs", "Import"); + } + } + + EditorGUILayout.BeginHorizontal(); + float buttonWidth = (EditorGUIUtility.currentViewWidth - 10) / 2f; + // Delete all PlayerPrefs + if (GUILayout.Button("Delete All Preferences", GUILayout.Width(buttonWidth))) + { + if (EditorUtility.DisplayDialog("Delete All?", "Are you sure you want to delete all preferences?", "Delete All", "Cancel")) + { + DeleteAll(); + Save(); + + // Clear the cache too, for an instant visibility update for OSX + deserializedPlayerPrefs.Clear(); + } + } + + GUILayout.FlexibleSpace(); + + // Mainly needed for OSX, this will encourage PlayerPrefs to save to file (but still may take a few seconds) + if (GUILayout.Button("Force Save", GUILayout.Width(buttonWidth))) + { + Save(); + } + EditorGUILayout.EndHorizontal(); + } + + private void DeserializePrefsIntoCache() + { + if (Application.platform == RuntimePlatform.OSXEditor) + { + string playerPrefsPath; + + if (showEditorPrefs) + { + playerPrefsPath = GetMacOSEditorPrefsPath(); + } + else + { + // From Unity Docs: On Mac OS X PlayerPrefs are stored in ~/Library/Preferences folder, in a file named unity.[company name].[product name].plist, where company and product names are the names set up in Project Settings. The same .plist file is used for both Projects run in the Editor and standalone players. + + // Construct the plist filename from the project's settings + string plistFilename = string.Format("unity.{0}.{1}.plist", PlayerSettings.companyName, PlayerSettings.productName); + // Now construct the fully qualified path + playerPrefsPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library/Preferences"), plistFilename); + } + + // Determine when the plist was last written to + DateTime lastWriteTime = File.GetLastWriteTimeUtc(playerPrefsPath); + + // If we haven't deserialized the PlayerPrefs already, or the written file has changed then deserialize + // the latest version + if (!lastDeserialization.HasValue || lastDeserialization.Value != lastWriteTime) + { + // Deserialize the actual PlayerPrefs from file into a cache + deserializedPlayerPrefs = new List(RetrieveSavedPrefs(PlayerSettings.companyName, PlayerSettings.productName)); + + // Record the version of the file we just read, so we know if it changes in the future + lastDeserialization = lastWriteTime; + } + + if (lastWriteTime != MISSING_DATETIME) + { + GUILayout.Label("Plist Last Written: " + lastWriteTime.ToString()); + } + else + { + GUILayout.Label("Plist Does Not Exist"); + } + } + else if (Application.platform == RuntimePlatform.WindowsEditor) + { + // Windows works a bit differently to OSX, we just regularly query the registry. So don't query too often + if (!lastDeserialization.HasValue || DateTime.UtcNow - lastDeserialization.Value > TimeSpan.FromMilliseconds(500)) + { + // Deserialize the actual PlayerPrefs from registry into a cache + deserializedPlayerPrefs = new List(RetrieveSavedPrefs(PlayerSettings.companyName, PlayerSettings.productName)); + + // Record the latest time, so we don't fetch again too quickly + lastDeserialization = DateTime.UtcNow; + } + } + } + + private void OnGUI() + { + EditorGUILayout.Space(); + + DrawTopBar(); + + DeserializePrefsIntoCache(); + + DrawMainList(); + + DrawAddEntry(); + + DrawBottomMenu(); + + // If the user has scrolled, deselect - this is because control IDs within carousel will change when scrolled + // so we'd end up with the wrong box selected. + if (scrollPosition != lastScrollPosition) + { + // Deselect + GUI.FocusControl(""); + } + } + + private void CacheRecord(string key, object value) + { + // First of all check if this key already exists, if so replace it's value with the new value + bool replaced = false; + + int entryCount = deserializedPlayerPrefs.Count; + for (int i = 0; i < entryCount; i++) + { + // Found the key - it exists already + if (deserializedPlayerPrefs[i].Key == key) + { + // Update the cached pref with the new value + deserializedPlayerPrefs[i] = new PlayerPrefPair() { Key = key, Value = value }; + // Mark the replacement so we no longer need to add it + replaced = true; + break; + } + } + + // PlayerPref doesn't already exist (and wasn't replaced) so add it as new + if (!replaced) + { + // Cache a PlayerPref the user just created so it can be instantly display (mainly for OSX) + deserializedPlayerPrefs.Add(new PlayerPrefPair() { Key = key, Value = value }); + } + + // Update the search if it's active + UpdateSearch(); + } + + private void DeleteCachedRecord(string fullKey) + { + keyQueuedForDeletion = fullKey; + } + + // OnInspectorUpdate() is called by Unity at 10 times a second + private void OnInspectorUpdate() + { + // If a PlayerPref has been specified for deletion + if (!string.IsNullOrEmpty(keyQueuedForDeletion)) + { + // If the user just deleted a PlayerPref, find the ID and defer it for deletion by OnInspectorUpdate() + if (deserializedPlayerPrefs != null) + { + int entryCount = deserializedPlayerPrefs.Count; + for (int i = 0; i < entryCount; i++) + { + if (deserializedPlayerPrefs[i].Key == keyQueuedForDeletion) + { + deserializedPlayerPrefs.RemoveAt(i); + break; + } + } + } + + // Remove the queued key since we've just deleted it + keyQueuedForDeletion = null; + + // Update the search results and repaint the window + UpdateSearch(); + Repaint(); + } + else if (inspectorUpdateFrame % 10 == 0) // Once a second (every 10th frame) + { + // Force the window to repaint + Repaint(); + } + + // Track what frame we're on, so we can call code less often + inspectorUpdateFrame++; + } + + public void Import(string companyName, string productName) + { + // Walk through all the imported PlayerPrefs and apply them to the current PlayerPrefs + PlayerPrefPair[] importedPairs = RetrieveSavedPrefs(companyName, productName); + for (int i = 0; i < importedPairs.Length; i++) + { + Type type = importedPairs[i].Value.GetType(); + if (type == typeof(float)) + SetFloat(importedPairs[i].Key, (float)importedPairs[i].Value); + else if (type == typeof(int)) + SetInt(importedPairs[i].Key, (int)importedPairs[i].Value); + else if (type == typeof(string)) + SetString(importedPairs[i].Key, (string)importedPairs[i].Value); + + // Cache any new records until they are reimported from disk + CacheRecord(importedPairs[i].Key, importedPairs[i].Value); + } + + // Force a save + Save(); + } + + bool UsingProSkin + { + get + { +#if UNITY_3_4 + if(EditorPrefs.GetInt("UserSkin") == 1) + { + return true; + } + else + { + return false; + } +#else + return EditorGUIUtility.isProSkin; +#endif + } + } + } +} diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs.meta new file mode 100644 index 00000000..709f2b12 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: dcb54795ee12a428e83ae9b68f6b7d7a +timeCreated: 1428611076 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime.meta new file mode 100644 index 00000000..f471addf --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 1140cb97bb897d34bafb342f3b381fa8 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs new file mode 100644 index 00000000..45a9ac35 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs @@ -0,0 +1,393 @@ +using System; +using System.Globalization; +using UnityEngine; + +namespace Sabresaurus.PlayerPrefsUtilities +{ + public static class PlayerPrefsUtility + { + // Each encrypted player pref key is given a prefix (this helps the Editor to identify them) + public const string KEY_PREFIX = "ENC-"; + + // Each encrypted value is prefixed with a type identifier (because encrypted values are stored as strings) + public const string VALUE_FLOAT_PREFIX = "0"; + public const string VALUE_INT_PREFIX = "1"; + public const string VALUE_STRING_PREFIX = "2"; + public const string VALUE_BOOL_PREFIX = "3"; + + /// + /// Determines if the specified player pref key refers to an encrypted record + /// + public static bool IsEncryptedKey(string key) + { + // Encrypted keys use a special prefix + if (key.StartsWith(KEY_PREFIX)) + { + return true; + } + else + { + return false; + } + } + + /// + /// Decrypts the specified key + /// + public static string DecryptKey(string encryptedKey) + { + if (encryptedKey.StartsWith(KEY_PREFIX)) + { + // Remove the key prefix from the encrypted key + string strippedKey = encryptedKey.Substring(KEY_PREFIX.Length); + // Return the decrypted key + return SimpleEncryption.DecryptString(strippedKey); + } + else + { + throw new InvalidOperationException("Could not decrypt item, no match found in known encrypted key prefixes"); + } + } + + /// + /// Encrypted version of PlayerPrefs.SetFloat(), stored key and value is encrypted in player prefs + /// + public static void SetEncryptedFloat(string key, float value) + { + string encryptedKey = SimpleEncryption.EncryptString(key); + string encryptedValue = SimpleEncryption.EncryptFloat(value); + + // Store the encrypted key and value (with relevant identifying prefixes) in PlayerPrefs + PlayerPrefs.SetString(KEY_PREFIX + encryptedKey, VALUE_FLOAT_PREFIX + encryptedValue); + } + + /// + /// Encrypted version of PlayerPrefs.SetInt(), stored key and value is encrypted in player prefs + /// + public static void SetEncryptedInt(string key, int value) + { + string encryptedKey = SimpleEncryption.EncryptString(key); + string encryptedValue = SimpleEncryption.EncryptInt(value); + + // Store the encrypted key and value (with relevant identifying prefixes) in PlayerPrefs + PlayerPrefs.SetString(KEY_PREFIX + encryptedKey, VALUE_INT_PREFIX + encryptedValue); + } + + /// + /// Encrypted version of PlayerPrefs.SetString(), stored key and value is encrypted in player prefs + /// + public static void SetEncryptedString(string key, string value) + { + string encryptedKey = SimpleEncryption.EncryptString(key); + string encryptedValue = SimpleEncryption.EncryptString(value); + + // Store the encrypted key and value (with relevant identifying prefixes) in PlayerPrefs + PlayerPrefs.SetString(KEY_PREFIX + encryptedKey, VALUE_STRING_PREFIX + encryptedValue); + } + + /// + /// Encrypted version of EditorPrefs.SetBool(), stored key and value is encrypted in player prefs + /// + public static void SetEncryptedBool(string key, bool value) + { + string encryptedKey = SimpleEncryption.EncryptString(key); + string encryptedValue = SimpleEncryption.EncryptBool(value); + + // Store the encrypted key and value (with relevant identifying prefixes) in PlayerPrefs + PlayerPrefs.SetString(KEY_PREFIX + encryptedKey, VALUE_BOOL_PREFIX + encryptedValue); + } + + /// + /// Helper method that can handle any of the encrypted player pref types, returning a float, int or string based + /// on what type of value has been stored. + /// + public static object GetEncryptedValue(string encryptedKey, string encryptedValue) + { + // See what type identifier the encrypted value starts + if (encryptedValue.StartsWith(VALUE_FLOAT_PREFIX)) + { + // It's a float, so decrypt it as a float and return the value + return GetEncryptedFloat(SimpleEncryption.DecryptString(encryptedKey.Substring(KEY_PREFIX.Length))); + } + else if (encryptedValue.StartsWith(VALUE_INT_PREFIX)) + { + // It's an int, so decrypt it as an int and return the value + return GetEncryptedInt(SimpleEncryption.DecryptString(encryptedKey.Substring(KEY_PREFIX.Length))); + } + else if (encryptedValue.StartsWith(VALUE_STRING_PREFIX)) + { + // It's a string, so decrypt it as a string and return the value + return GetEncryptedString(SimpleEncryption.DecryptString(encryptedKey.Substring(KEY_PREFIX.Length))); + } + else if (encryptedValue.StartsWith(VALUE_BOOL_PREFIX)) + { + // It's a string, so decrypt it as a string and return the value + return GetEncryptedBool(SimpleEncryption.DecryptString(encryptedKey.Substring(KEY_PREFIX.Length))); + } + else + { + throw new InvalidOperationException("Could not decrypt item, no match found in known encrypted key prefixes"); + } + } + + /// + /// Encrypted version of PlayerPrefs.GetFloat(), an unencrypted key is passed and the value is returned decrypted + /// + public static float GetEncryptedFloat(string key, float defaultValue = 0.0f) + { + // Encrypt and prefix the key so we can look it up from player prefs + string encryptedKey = KEY_PREFIX + SimpleEncryption.EncryptString(key); + + // Look up the encrypted value + string fetchedString = PlayerPrefs.GetString(encryptedKey); + + if (!string.IsNullOrEmpty(fetchedString)) + { + // Strip out the type identifier character + fetchedString = fetchedString.Remove(0, 1); + + // Decrypt and return the float value + return SimpleEncryption.DecryptFloat(fetchedString); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Encrypted version of PlayerPrefs.GetInt(), an unencrypted key is passed and the value is returned decrypted + /// + public static int GetEncryptedInt(string key, int defaultValue = 0) + { + // Encrypt and prefix the key so we can look it up from player prefs + string encryptedKey = KEY_PREFIX + SimpleEncryption.EncryptString(key); + + // Look up the encrypted value + string fetchedString = PlayerPrefs.GetString(encryptedKey); + + if (!string.IsNullOrEmpty(fetchedString)) + { + // Strip out the type identifier character + fetchedString = fetchedString.Remove(0, 1); + + // Decrypt and return the int value + return SimpleEncryption.DecryptInt(fetchedString); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Encrypted version of PlayerPrefs.GetString(), an unencrypted key is passed and the value is returned decrypted + /// + public static string GetEncryptedString(string key, string defaultValue = "") + { + // Encrypt and prefix the key so we can look it up from player prefs + string encryptedKey = KEY_PREFIX + SimpleEncryption.EncryptString(key); + + // Look up the encrypted value + string fetchedString = PlayerPrefs.GetString(encryptedKey); + + if (!string.IsNullOrEmpty(fetchedString)) + { + // Strip out the type identifier character + fetchedString = fetchedString.Remove(0, 1); + + // Decrypt and return the string value + return SimpleEncryption.DecryptString(fetchedString); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Encrypted version of EditorPrefs.GetBool(), an unencrypted key is passed and the value is returned decrypted + /// + public static bool GetEncryptedBool(string key, bool defaultValue = false) + { + // Encrypt and prefix the key so we can look it up from player prefs + string encryptedKey = KEY_PREFIX + SimpleEncryption.EncryptString(key); + + // Look up the encrypted value + string fetchedString = PlayerPrefs.GetString(encryptedKey); + + if (!string.IsNullOrEmpty(fetchedString)) + { + // Strip out the type identifier character + fetchedString = fetchedString.Remove(0, 1); + + // Decrypt and return the int value + return SimpleEncryption.DecryptBool(fetchedString); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Helper method to store a bool in PlayerPrefs (stored as an int) + /// + public static void SetBool(string key, bool value) + { + // Store the bool as an int (1 for true, 0 for false) + if (value) + { + PlayerPrefs.SetInt(key, 1); + } + else + { + PlayerPrefs.SetInt(key, 0); + } + } + + /// + /// Helper method to retrieve a bool from PlayerPrefs (stored as an int) + /// + public static bool GetBool(string key, bool defaultValue = false) + { + // Use HasKey to check if the bool has been stored (as int defaults to 0 which is ambiguous with a stored False) + if (PlayerPrefs.HasKey(key)) + { + int value = PlayerPrefs.GetInt(key); + + // As in C, assume zero is false and any non-zero value (including its intended 1) is true + if (value != 0) + { + return true; + } + else + { + return false; + } + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Helper method to store an enum value in PlayerPrefs (stored using the string name of the enum) + /// + public static void SetEnum(string key, Enum value) + { + // Convert the enum value to its string name (as opposed to integer index) and store it in a string PlayerPref + PlayerPrefs.SetString(key, value.ToString()); + } + + /// + /// Generic helper method to retrieve an enum value from PlayerPrefs and parse it from its stored string into the + /// specified generic type. This method should generally be preferred over the non-generic equivalent + /// + public static T GetEnum(string key, T defaultValue = default(T)) where T : struct + { + // Fetch the string value from PlayerPrefs + string stringValue = PlayerPrefs.GetString(key); + + if (!string.IsNullOrEmpty(stringValue)) + { + // Existing value, so parse it using the supplied generic type and cast before returning it + return (T)Enum.Parse(typeof(T), stringValue); + } + else + { + // No player pref for this, just return default. If no default is supplied this will be the enum's default + return defaultValue; + } + } + + /// + /// Non-generic helper method to retrieve an enum value from PlayerPrefs (stored as a string). Default value must be + /// passed, passing null will mean you need to do a null check where you call this method. Generally try to use the + /// generic version of this method instead: GetEnum + /// + public static object GetEnum(string key, Type enumType, object defaultValue) + { + // Fetch the string value from PlayerPrefs + string value = PlayerPrefs.GetString(key); + + if (!string.IsNullOrEmpty(value)) + { + // Existing value, parse it using the supplied type, then return the result as an object + return Enum.Parse(enumType, value); + } + else + { + // No player pref for this key, so just return supplied default. It's required to supply a default value, + // you can just pass null, but you would then need to do a null check where you call non-generic GetEnum(). + // Consider using GetEnum() which doesn't require a default to be passed (supplying default(T) instead) + return defaultValue; + } + } + + /// + /// Helper method to store a DateTime (complete with its timezone) in PlayerPrefs as a string + /// + public static void SetDateTime(string key, DateTime value) + { + // Convert to an ISO 8601 compliant string ("o"), so that it's fully qualified, then store in PlayerPrefs + PlayerPrefs.SetString(key, value.ToString("o", CultureInfo.InvariantCulture)); + } + + /// + /// Helper method to retrieve a DateTime from PlayerPrefs (stored as a string) and return a DateTime complete with + /// timezone (works with UTC and local DateTimes) + /// + public static DateTime GetDateTime(string key, DateTime defaultValue = new DateTime()) + { + // Fetch the string value from PlayerPrefs + string stringValue = PlayerPrefs.GetString(key); + + if (!string.IsNullOrEmpty(stringValue)) + { + // Make sure to parse it using Roundtrip Kind otherwise a local time would come out as UTC + return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + + /// + /// Helper method to store a TimeSpan in PlayerPrefs as a string + /// + public static void SetTimeSpan(string key, TimeSpan value) + { + // Use the TimeSpan's ToString() method to encode it as a string which is then stored in PlayerPrefs + PlayerPrefs.SetString(key, value.ToString()); + } + + /// + /// Helper method to retrieve a TimeSpan from PlayerPrefs (stored as a string) + /// + public static TimeSpan GetTimeSpan(string key, TimeSpan defaultValue = new TimeSpan()) + { + // Fetch the string value from PlayerPrefs + string stringValue = PlayerPrefs.GetString(key); + + if (!string.IsNullOrEmpty(stringValue)) + { + // Parse the string and return the TimeSpan + return TimeSpan.Parse(stringValue); + } + else + { + // No existing player pref value, so return defaultValue instead + return defaultValue; + } + } + } +} diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs.meta new file mode 100644 index 00000000..78802e72 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/PlayerPrefsUtility.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f771cedf20c294a53bf8ddd90a3b5492 +timeCreated: 1428611079 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs new file mode 100644 index 00000000..452a4dad --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs @@ -0,0 +1,167 @@ +using System; +using System.Security.Cryptography; +using System.Text; + +namespace Sabresaurus.PlayerPrefsUtilities +{ + public static class SimpleEncryption + { + // IMPORTANT: Make sure to change this key for each project you use this encryption in to help secure your + // encrypted values. This key must be exactly 32 characters long (256 bit). + private static string key = ":{j%6j?E:t#}G10mM%9hp5S=%}2,Y26C"; + + // Cache the encryption provider + private static RijndaelManaged provider = null; + + private static void SetupProvider() + { + // Create a new encryption provider + provider = new RijndaelManaged(); + + // Get the bytes from the supplied string key and use it as the provider's key + provider.Key = Encoding.ASCII.GetBytes(key); + + // Ensure that the same data is always encrypted the same way when used with the same key + provider.Mode = CipherMode.ECB; + } + + /// + /// Encrypts the specified string using the key stored in SimpleEncryption and returns the encrypted result + /// + public static string EncryptString(string sourceString) + { + if (provider == null) + { + // Encryption provider hasn't been set up yet, so set it up + SetupProvider(); + } + + // Create an encryptor to encrypt the bytes + ICryptoTransform encryptor = provider.CreateEncryptor(); + + // Convert the source string into bytes to be encrypted + byte[] sourceBytes = Encoding.UTF8.GetBytes(sourceString); + + // Encrypt the bytes using the encryptor we just created + byte[] outputBytes = encryptor.TransformFinalBlock(sourceBytes, 0, sourceBytes.Length); + + // Convert the encrypted bytes into a Base 64 string, so we can safely represent them as a string and return + // that string + return Convert.ToBase64String(outputBytes); + } + + /// + /// Decrypts the specified string from its specified encrypted value into the returned decrypted value using the + /// key stored in SimpleEncryption + /// + public static string DecryptString(string sourceString) + { + if (provider == null) + { + // Encryption provider hasn't been set up yet, so set it up + SetupProvider(); + } + + // Create a decryptor to decrypt the encrypted bytes + ICryptoTransform decryptor = provider.CreateDecryptor(); + + // Convert the base 64 string representing the encrypted bytes back into an array of encrypted bytes + byte[] sourceBytes = Convert.FromBase64String(sourceString); + + // Use the decryptor we just created to decrypt those bytes + byte[] outputBytes = decryptor.TransformFinalBlock(sourceBytes, 0, sourceBytes.Length); + + // Turn the decrypted bytes back into the decrypted string and return it + return Encoding.UTF8.GetString(outputBytes); + } + + /// + /// Encrypts the specified float value and returns an encrypted string + /// + public static string EncryptFloat(float value) + { + // Convert the float into its 4 bytes + byte[] bytes = BitConverter.GetBytes(value); + + // Represent those bytes as a base 64 string + string base64 = Convert.ToBase64String(bytes); + + // Return the encrypted version of that base 64 string + return SimpleEncryption.EncryptString(base64); + } + + /// + /// Encrypts the specified int value and returns an encrypted string + /// + public static string EncryptInt(int value) + { + // Convert the int value into its 4 bytes + byte[] bytes = BitConverter.GetBytes(value); + + // Represent those bytes as a base 64 string + string base64 = Convert.ToBase64String(bytes); + + // Return the encrypted version of that base 64 string + return SimpleEncryption.EncryptString(base64); + } + + /// Encrypts the specified bool value and returns an encrypted string + /// + public static string EncryptBool(bool value) + { + // Convert the bool value into its 4 bytes + byte[] bytes = BitConverter.GetBytes(value); + + // Represent those bytes as a base 64 string + string base64 = Convert.ToBase64String(bytes); + + // Return the encrypted version of that base 64 string + return SimpleEncryption.EncryptString(base64); + } + + /// + /// Decrypts the encrypted string representing a float into the decrypted float + /// + public static float DecryptFloat(string sourceString) + { + // Decrypt the encrypted string + string decryptedString = SimpleEncryption.DecryptString(sourceString); + + // Convert the decrypted Base 64 representation back into bytes + byte[] bytes = Convert.FromBase64String(decryptedString); + + // Turn the bytes back into a float and return it + return BitConverter.ToSingle(bytes, 0); + } + + /// + /// Decrypts the encrypted string representing an int into the decrypted int + /// + public static int DecryptInt(string sourceString) + { + // Decrypt the encrypted string + string decryptedString = SimpleEncryption.DecryptString(sourceString); + + // Convert the decrypted Base 64 representation back into bytes + byte[] bytes = Convert.FromBase64String(decryptedString); + + // Turn the bytes back into a int and return it + return BitConverter.ToInt32(bytes, 0); + } + + /// + /// Decrypts the encrypted string representing a bool into the decrypted bool + /// + public static bool DecryptBool(string sourceString) + { + // Decrypt the encrypted string + string decryptedString = SimpleEncryption.DecryptString(sourceString); + + // Convert the decrypted Base 64 representation back into bytes + byte[] bytes = Convert.FromBase64String(decryptedString); + + // Turn the bytes back into a bool and return it + return BitConverter.ToBoolean(bytes, 0); + } + } +} diff --git a/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs.meta b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs.meta new file mode 100644 index 00000000..00b910c3 --- /dev/null +++ b/Assets/TEngine/Editor/PlayerPrefsEditor/Runtime/SimpleEncryption.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5e991f28b70f34623b5407b05ba3e641 +timeCreated: 1428611076 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: