//------------------------------------------------------------------------------
public bool Load(string settingName, SettingBaseAttribute attr, out object value)
{
bool loadSuccess = false;
var prefs = GetSharedPreferences();
if (!prefs.Contains(settingName))
{
value = null;
loadSuccess = false;
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"SharedPreferencesSerializer.Load - no such setting",
settingName);
}
else
{
// in this case simplification will be made in the SettingsSerializer.cs
loadSuccess = prefs.All.TryGetValue(settingName, out value);
if (loadSuccess)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"SharedPreferencesSerializer.Load - success",
settingName);
}
else
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
"SharedPreferencesSerializer.Load - error",
settingName);
}
}
return(loadSuccess);
}
//------------------------------------------------------------------------------
public bool Load(string settingName, SettingBaseAttribute attr, out object value)
{
settingName = SettingNamePrefix + settingName;
object encryptedValue;
bool loaded = m_Store.Load(settingName, attr, out encryptedValue);
if (loaded)
{
var encryptedBase64StringData = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(encryptedValue);
byte[] encryptedBytes = Convert.FromBase64String(encryptedBase64StringData);
var entropy = SettingsConfiguration.SecureSettingsAdditionalEntropy;
var decryptedValue = ProtectedData.Unprotect(encryptedBytes, entropy, SettingsConfiguration.SecureSettingsScope);
value = Encoding.ASCII.GetString(decryptedValue);
}
else
{
value = null;
}
return(loaded);
}
//------------------------------------------------------------------------------
public bool Contains(string settingName, SettingBaseAttribute attr)
{
return(m_Store.Contains(settingName, attr));
}
//------------------------------------------------------------------------------
public void Delete(string settingName, SettingBaseAttribute attr)
{
m_Store.Delete(settingName, attr);
}
//------------------------------------------------------------------------------
public bool Contains(string settingName, SettingBaseAttribute attr)
{
bool contains = m_Store.FileExists(settingName);
return(contains);
}
//------------------------------------------------------------------------------
public void Delete(string settingName, bool secure, SettingBaseAttribute attr)
{
IInternalSettingsSerializer serializer = GetSerializer(secure);
serializer.Delete(settingName, attr);
}
//------------------------------------------------------------------------------
public void Save(string settingName, bool secure, SettingBaseAttribute attr, object value)
{
IInternalSettingsSerializer serializer = GetSerializer(secure);
serializer.Save(settingName, attr, value);
}
//------------------------------------------------------------------------------
public bool Load(string settingName, bool secure, SettingBaseAttribute attr, out object value)
{
IInternalSettingsSerializer serializer = GetSerializer(secure);
return(serializer.Load(settingName, attr, out value));
}
//------------------------------------------------------------------------------
public static bool ProcessSetting(SettingsObjectInfo settingsObjectInfo,
SettingInfo inSettingInfo,
SettingsEnumerationMode mode,
SettingsHelperData settingsHelperData,
out SettingInfo outSettingInfo,
FunctionalityHook functionalityHook)
{
bool processStatus = false;
outSettingInfo = new SettingInfo();
SettingBaseAttribute settingBaseAttribute = null;
if (settingsObjectInfo.MemberInfo != null)
{
settingBaseAttribute = settingsObjectInfo.MemberInfo.GetCustomAttribute <SettingBaseAttribute>();
if (settingBaseAttribute == null)
{
return(false);
}
}
ISettingsSerializer serializer = null;
if (settingsObjectInfo.MemberInfo != null)
{
serializer = GetSerializerForMemberInfo(settingsObjectInfo.Settings,
settingsObjectInfo.ForegroundSerializer,
settingsObjectInfo.MemberInfo,
ref settingsHelperData.SerializersCache);
}
else
{
serializer = GetSerializerForSettingAttributeType(settingsObjectInfo.Settings,
settingsObjectInfo.ForegroundSerializer,
settingsObjectInfo.SettingAttributeType,
ref settingsHelperData.SerializersCache);
}
Debug.Assert(serializer != null);
if (settingsObjectInfo.MemberInfo != null)
{
inSettingInfo.SettingName = SettingNameFormatInfo.GetFullSettingName(settingsObjectInfo.Settings.GetType(),
settingsObjectInfo.MemberInfo,
settingBaseAttribute,
serializer as ISettingsSerializerWishes,
SettingNameMode.Static);
}
if (settingsObjectInfo.MemberInfo != null)
{
var settingValueType = SettingsSerializer.GetSettingType(settingsObjectInfo.MemberInfo);
inSettingInfo.SettingValueType = settingValueType;
inSettingInfo.SettingValue = SettingsSerializer.GetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings);
}
bool secure = false;
var settingSecureAttr = settingBaseAttribute as SettingAttribute;
if (settingSecureAttr != null)
{
secure = settingSecureAttr.Secure;
}
switch (mode)
{
case SettingsEnumerationMode.Load:
{
Wrapper defaultValueWrapper = null;
if (settingBaseAttribute != null && settingBaseAttribute.DefaultValueInUse)
{
var defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
defaultValueWrapper = new Wrapper()
{
Value = defaultValue
};
}
processStatus = SettingsSerializer.Load(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
defaultValueWrapper,
inSettingInfo.SettingValueType,
ref outSettingInfo,
functionalityHook);
// outSettingInfo.SettingValue type was corrected
// in the SettingsSerializer.Load method
if (processStatus && settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings, outSettingInfo.SettingValue);
}
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Load,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.Save:
{
if (settingsObjectInfo.MemberInfo != null)
{
inSettingInfo.SettingValue = SettingsSerializer.GetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings);
}
processStatus = SettingsSerializer.Save(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
inSettingInfo.SettingValue,
functionalityHook);
settingsHelperData.SerializersToSync.Add(serializer);
outSettingInfo = inSettingInfo;
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Save,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.Delete:
{
processStatus = SettingsSerializer.Delete(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
functionalityHook);
settingsHelperData.SerializersToSync.Add(serializer);
object defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
outSettingInfo.SettingName = inSettingInfo.SettingName;
outSettingInfo.SettingValue = defaultValue;
outSettingInfo.SettingDefaultValue = defaultValue;
outSettingInfo.SettingValueType = inSettingInfo.SettingValueType;
if (processStatus && settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo,
settingsObjectInfo.Settings,
defaultValue);
}
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Delete,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.LoadDefaults:
{
Debug.Assert(inSettingInfo.SettingValueType != null);
var defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
if (settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo,
settingsObjectInfo.Settings,
defaultValue);
}
outSettingInfo.SettingName = inSettingInfo.SettingName;
outSettingInfo.SettingValue = defaultValue;
outSettingInfo.SettingDefaultValue = defaultValue;
outSettingInfo.SettingValueType = inSettingInfo.SettingValueType;
processStatus = true;
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.LoadDefaults,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
default:
Debug.Assert(false);
throw new NotImplementedException(String.Format("Not implemented for '{0}' mode", mode));
}
return(processStatus);
}
//------------------------------------------------------------------------------
static ISettingsSerializer GetSerializerForMember(SettingsObjectInfo settingsObjectInfo,
ref Dictionary <Type, KeyValuePair <ISettingsSerializer, bool> > serializersCache)
{
if (settingsObjectInfo.SettingAttributeType == null)
{
if (settingsObjectInfo.MemberInfo == null)
{
throw new ArgumentNullException(nameof(settingsObjectInfo.MemberInfo));
}
SettingBaseAttribute settingBaseAttr = settingsObjectInfo.MemberInfo.GetCustomAttribute <SettingBaseAttribute>();
if (settingBaseAttr == null)
{
return(null);
}
settingsObjectInfo.SettingAttributeType = settingBaseAttr.GetType();
}
ISettingsSerializer serializer = settingsObjectInfo.ForegroundSerializer;
bool skipExternalSerializer = false;
ISettingsSerializer attributeSerializer = null;
// try to get setting attribute corresponding serializer
if (serializer == null)
{
var serializerInfo = GetSerializerInfoDependFromSettingAttributeType(settingsObjectInfo.Settings, settingsObjectInfo.SettingAttributeType, ref serializersCache);
attributeSerializer = serializerInfo.Key;
skipExternalSerializer = serializerInfo.Value;
}
if (settingsObjectInfo.MemberInfo != null)
{
// try to get setting (field) serializer
if (serializer == null && !skipExternalSerializer)
{
SerializerAttribute serializerAttr = settingsObjectInfo.MemberInfo.GetCustomAttribute <SerializerAttribute>();
MethodSerializerAttribute methodSerializerAttrForField = settingsObjectInfo.MemberInfo.GetCustomAttribute <MethodSerializerAttribute>();
if (methodSerializerAttrForField != null)
{
serializer = new MethodSerializerForField(methodSerializerAttrForField, settingsObjectInfo.Settings);
}
else if (serializerAttr != null)
{
serializer = GetCustomSerializer(settingsObjectInfo.Settings, serializerAttr.Type, ref serializersCache).Key;
}
}
}
// try to get class serializer
if (serializer == null && !skipExternalSerializer)
{
SerializerAttribute serializerAttr = settingsObjectInfo.Settings.GetType().GetTypeInfo().
GetCustomAttribute <SerializerAttribute>();
MethodSerializerAttribute methodSerializerAttrForClass = settingsObjectInfo.Settings.GetType().GetTypeInfo().
GetCustomAttribute <MethodSerializerAttribute>();
if (methodSerializerAttrForClass != null)
{
serializer = new MethodSerializerForClass(methodSerializerAttrForClass, settingsObjectInfo.Settings);
}
else if (serializerAttr != null)
{
serializer = GetCustomSerializer(settingsObjectInfo.Settings, serializerAttr.Type, ref serializersCache).Key;
}
}
// try to get library serializer
if (serializer == null && !skipExternalSerializer)
{
serializer = SettingsBaseConfiguration.Serializer;
}
// try to get attribute serializer in case if allowed
if (serializer == null && !skipExternalSerializer)
{
serializer = attributeSerializer;
}
return(serializer);
}
/*
* //------------------------------------------------------------------------------
* static bool TryToMigrateFromPrevFormat(ISettingsSerializer serializer,
* string curentSettingName, bool secure,
* Type settingType,
* out object value)
* {
* var delimeter = SettingNameFormatInfo.GetSettingNameDelimeter(serializer as ISettingsSerializerWishes);
* SettingNameFormatInfo fi = new SettingNameFormatInfo(curentSettingName, delimeter, SettingNameMode.Unknown);
*
* try
* {
* InternalConfiguration.PlatformHelper.Log(LogLevel.Info, "Format migration",
* String.Format("Try to migrate '{0}' from previous format version", curentSettingName));
* bool loaded = serializer.Load(fi.V1SettingName, secure, out value);
*
* if (loaded)
* {
* value = InternalConfiguration.PlatformHelper.CorrectSettingType_V1(value, settingType);
*
* InternalConfiguration.PlatformHelper.Log(LogLevel.Info, "Format migration",
* String.Format("From '{0}' to '{1}' - success",
* fi.V1SettingName, curentSettingName));
*
* return true;
* }
* else
* {
* InternalConfiguration.PlatformHelper.Log(LogLevel.Info, "Format migration",
* String.Format("'{0}' skip migration, no previous value", curentSettingName));
* }
* }
* catch (Exception exc)
* {
* InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
* String.Format("Exception during format migration from '{0}' to '{1}'",
* fi.V1SettingName, curentSettingName),
* exc);
* }
*
* value = null;
*
* return false;
* }
*/
//------------------------------------------------------------------------------
static public bool Load(ISettingsSerializer serializer,
SettingBaseAttribute attr,
string settingName, bool secure,
Wrapper attributeDefaultValueWrapper,
Type destinationType,
ref SettingInfo outSettingInfo,
FunctionalityHook functionalityHook)
{
bool valueWasLoaded = false;
object loadedValue = null;
object defaultValue;
if (attributeDefaultValueWrapper != null)
{
defaultValue = attributeDefaultValueWrapper.Value;
}
else
{
defaultValue = GetTypeDefaultValue(destinationType);
}
try
{
valueWasLoaded = serializer.Load(settingName, secure, attr, out loadedValue);
bool valueWasSet = false;
if (valueWasLoaded)
{
// CorrectValueType in case of exception default value will be returned
var outTuple = CorrectValueType(loadedValue, destinationType, defaultValue, functionalityHook);
outSettingInfo.SettingValue = outTuple.Item1;
outSettingInfo.SettingValueType = outTuple.Item2;
outSettingInfo.SettingDefaultValue = outTuple.Item3;
outSettingInfo.SettingName = settingName;
valueWasSet = true;
}
else
{
bool valueWasMigrated = false;
object migratedValue = null;
/*
* if (SettingsBaseConfiguration.EnableFormatMigration)
* {
* try
* {
* valueWasMigrated = TryToMigrateFromPrevFormat(serializer, settingName, secure, destinationType, out migratedValue);
* }
* catch(Exception exc)
* {
* InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
* String.Format("Format migration exception for setting '{0}'", settingName),
* exc);
*
* return false;
* }
* }
*/
if (valueWasMigrated)
{
// in success, object with non-curent type can be returned
// correct setting type
// CorrectValueType function in case of exception return default value
var outTuple = CorrectValueType(migratedValue, destinationType, defaultValue, functionalityHook);
outSettingInfo.SettingValue = outTuple.Item1;
outSettingInfo.SettingValueType = outTuple.Item2;
outSettingInfo.SettingDefaultValue = outTuple.Item3;
outSettingInfo.SettingName = settingName;
valueWasSet = true;
}
else if (attributeDefaultValueWrapper != null)
{
// Use default value only if it was set
outSettingInfo.SettingValue = defaultValue;
outSettingInfo.SettingValueType = destinationType;
outSettingInfo.SettingDefaultValue = defaultValue;
outSettingInfo.SettingName = settingName;
valueWasSet = true;
}
}
return(valueWasSet);
}
catch (ExceptionForUser exc)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
String.Format("Load exception for setting '{0}'", settingName),
exc.InnerException);
throw exc.InnerException;
}
catch (Exception exc)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
String.Format("Load exception for setting '{0}'", settingName),
exc);
}
return(false);
}
//------------------------------------------------------------------------------
public static bool TryGetSettingMetadata <T>(Expression <Func <ST, T> > value, string metadataName, out object metadataValue)
{
SettingBaseAttribute settingBaseAttribute = GetSettingBaseAttribute(value);
return(TryGetObjectSettingMetadata(Instance, settingBaseAttribute.Name, metadataName, out metadataValue));
}
//------------------------------------------------------------------------------
public static void SetSettingMetadata <T>(Expression <Func <ST, T> > value, string metadataName, object metadataValue)
{
SettingBaseAttribute settingBaseAttribute = GetSettingBaseAttribute(value);
SetObjectSettingMetadata(Instance, settingBaseAttribute.Name, metadataName, metadataValue);
}
