//------------------------------------------------------------------------------ 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); }