private void BuildContent <T>(T value)
{
if (value == null)
{
return;
}
byte[] bodyData = null;
switch (Format)
{
case DataFormat.Json:
var json = JsonFx.Json.JsonWriter.Serialize(value);
bodyData = Encoding.UTF8.GetBytes(json);
break;
case DataFormat.MessagePack:
MessagePackValidater.ValidateAttribute(typeof(T));
bodyData = MessagePackSerializer.Serialize(value, UnityContractResolver.Instance);
break;
}
bodyData = Encrypt(bodyData);
request.uploadHandler = new UploadHandlerRaw(bodyData);
}
public static T Get <T>() where T : LocalData, new()
{
T result = null;
MessagePackValidater.ValidateAttribute(typeof(T));
var filePath = Instance.GetLocalDataFilePath <T>();
if (File.Exists(filePath))
{
using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var bytes = new byte[fileStream.Length];
fileStream.Read(bytes, 0, bytes.Length);
bytes = bytes.Decrypt(Instance.aesManaged);
var options = StandardResolverAllowPrivate.Options
.WithCompression(MessagePackCompression.Lz4BlockArray)
.WithResolver(UnityContractResolver.Instance);
result = MessagePackSerializer.Deserialize <T>(bytes, options);
}
}
if (result == null)
{
result = new T();
}
return(result);
}
private TResult Deserialize <TResult>(byte[] value) where TResult : class
{
if (value == null || value.IsEmpty())
{
return(null);
}
TResult result = null;
value = Decrypt(value);
switch (Format)
{
case DataFormat.Json:
{
if (Compress)
{
value = value.Decompress();
}
var json = Encoding.UTF8.GetString(value);
if (!string.IsNullOrEmpty(json))
{
result = JsonConvert.DeserializeObject <TResult>(json);
}
}
break;
case DataFormat.MessagePack:
{
MessagePackValidater.ValidateAttribute(typeof(TResult));
if (value != null && value.Any())
{
var options = StandardResolverAllowPrivate.Options.WithResolver(UnityContractResolver.Instance);
if (Compress)
{
options = options.WithCompression(MessagePackCompression.Lz4Block);
}
result = MessagePackSerializer.Deserialize <TResult>(value, options);
}
}
break;
}
return(result);
}
private bool SaveCache(object[] masterData, string applicationVersion, string masterVersion, AesManaged aesManaged)
{
try
{
var master = masterData.Select(x => (T)Activator.CreateInstance(typeof(T), x)).ToArray();
SetMaster(master);
var installPath = GetLocalCacheFilePath();
var directory = Path.GetDirectoryName(installPath);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
#if UNITY_EDITOR
MessagePackValidater.ValidateAttribute(typeof(TCache));
MessagePackValidater.ValidateAttribute(typeof(T));
#endif
var cacheData = new TCache()
{
values = masters.Values.ToArray()
};
var data = LZ4MessagePackSerializer.Serialize(cacheData, UnityContractResolver.Instance);
var encrypt = data.Encrypt(aesManaged);
File.WriteAllBytes(installPath, encrypt);
versionPrefs.version = ConvertVersionStr(applicationVersion, masterVersion);
}
catch (Exception exception)
{
Debug.LogException(exception);
OnError();
return(false);
}
return(true);
}
public static void Save <T>(T data) where T : LocalData, new()
{
MessagePackValidater.ValidateAttribute(typeof(T));
var filePath = Instance.GetLocalDataFilePath <T>();
using (var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
var options = StandardResolverAllowPrivate.Options
.WithCompression(MessagePackCompression.Lz4BlockArray)
.WithResolver(UnityContractResolver.Instance);
var bytes = MessagePackSerializer.Serialize(data, options);
bytes = bytes.Encrypt(Instance.aesManaged);
fileStream.Write(bytes, 0, bytes.Length);
}
}
protected virtual UploadHandler CreateUploadHandler <TContent>(TContent content)
{
if (content == null)
{
return(null);
}
byte[] bodyData = null;
switch (Format)
{
case DataFormat.Json:
{
var json = JsonConvert.SerializeObject(content);
bodyData = Encoding.UTF8.GetBytes(json);
if (Compress)
{
bodyData = bodyData.Compress();
}
}
break;
case DataFormat.MessagePack:
{
MessagePackValidater.ValidateAttribute(typeof(TContent));
var options = StandardResolverAllowPrivate.Options.WithResolver(UnityContractResolver.Instance);
if (Compress)
{
options = options.WithCompression(MessagePackCompression.Lz4Block);
}
bodyData = MessagePackSerializer.Serialize(content, options);
}
break;
}
bodyData = Encrypt(bodyData);
return(new UploadHandlerRaw(bodyData));
}
private TResult Deserialize <TResult>(byte[] value) where TResult : class
{
if (value == null || value.IsEmpty())
{
return(null);
}
TResult result = null;
value = Decrypt(value);
switch (Format)
{
case DataFormat.Json:
var json = Encoding.UTF8.GetString(value);
if (!string.IsNullOrEmpty(json))
{
result = JsonFx.Json.JsonReader.Deserialize <TResult>(json);
}
break;
case DataFormat.MessagePack:
MessagePackValidater.ValidateAttribute(typeof(TResult));
if (value != null && value.Any())
{
result = MessagePackSerializer.Deserialize <TResult>(value, UnityContractResolver.Instance);
}
break;
}
return(result);
}
private IEnumerator LoadInternal(IObserver <bool> observer, AesManaged aesManaged)
{
var result = false;
#if UNITY_EDITOR
try
{
MessagePackValidater.ValidateAttribute(typeof(TMasterRecord));
}
catch (Exception exception)
{
Debug.LogException(exception);
}
#endif
var installPath = MasterManager.Instance.GetInstallPath <TMaster>();
Func <string, AesManaged, byte[]> loadCacheFile = (_installPath, _aesManaged) =>
{
// ファイル読み込み.
var data = File.ReadAllBytes(_installPath);
// 復号化.
return(data.Decrypt(_aesManaged));
};
// ファイルの読み込みと復号化をスレッドプールで実行.
var loadYield = Observable.Start(() => loadCacheFile(installPath, aesManaged)).ObserveOnMainThread().ToYieldInstruction();
while (!loadYield.IsDone)
{
yield return(null);
}
if (!loadYield.HasError)
{
if (loadYield.HasResult)
{
var bytes = loadYield.Result;
try
{
var options = StandardResolverAllowPrivate.Options
.WithCompression(MessagePackCompression.Lz4BlockArray)
.WithResolver(UnityContractResolver.Instance);
var container = MessagePackSerializer.Deserialize <TMasterContainer>(bytes, options);
SetRecords(container.records);
result = true;
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
}
else
{
Debug.LogException(loadYield.Error);
}
if (!result)
{
File.Delete(installPath);
OnError();
}
observer.OnNext(result);
observer.OnCompleted();
}
private IEnumerator LoadCacheInternal(IObserver <bool> observer, AesManaged aesManaged)
{
var sw = System.Diagnostics.Stopwatch.StartNew();
#if UNITY_EDITOR
try
{
MessagePackValidater.ValidateAttribute(typeof(TCache));
MessagePackValidater.ValidateAttribute(typeof(T));
}
catch (Exception exception)
{
Debug.LogException(exception);
}
#endif
var installPath = GetLocalCacheFilePath();
Func <string, AesManaged, byte[]> loadCacheFile = (_installPath, _aesManaged) =>
{
// ファイル読み込み.
var data = File.ReadAllBytes(_installPath);
// 復号化.
return(data.Decrypt(_aesManaged));
};
// ファイルの読み込みと復号化をスレッドプールで実行.
var loadYield = Observable.Start(() => loadCacheFile(installPath, aesManaged)).ObserveOnMainThread().ToYieldInstruction();
while (!loadYield.IsDone)
{
yield return(null);
}
var result = false;
if (loadYield.HasResult)
{
var data = loadYield.Result;
try
{
var cachedData = LZ4MessagePackSerializer.Deserialize <TCache>(data, UnityContractResolver.Instance);
SetMaster(cachedData.values);
result = true;
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
sw.Stop();
if (result)
{
MasterCacheLoadDiagnostic.Instance.Register <TInstance>(sw.Elapsed.TotalMilliseconds);
}
else
{
File.Delete(installPath);
OnError();
}
observer.OnNext(result);
observer.OnCompleted();
}
