//------------------------------------------------------------------------------
public static object MakeDynamicSetting(SettingInfo inSettingInfo)
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(inSettingInfo.SettingValue);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
return(stringValue);
}
//------------------------------------------------------------------------------
public static Tuple <object /*value*/, Type /*destinationType*/, object /*defaultValue*/> CorrectValueType(object value,
Type destinationType,
object defaultValue,
FunctionalityHook functionalityHook)
{
Tuple <object, Type, object> result;
try
{
if (functionalityHook != null && functionalityHook.TypeCorrector != null)
{
result = functionalityHook.TypeCorrector.CorrectType(value, destinationType, defaultValue);
}
else
{
object settingValue = SettingsSerializerHelper.CorrectSettingType(value, destinationType);
result = Tuple.Create(settingValue, destinationType, defaultValue);
}
}
catch (Exception exc)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error, exc);
//throw;
result = Tuple.Create(defaultValue, destinationType, defaultValue);
}
return(result);
}
public static NSObject ToNSObject(this Object obj)
{
var simpleObj = SettingsSerializerHelper.SimplifyObject(obj);
Debug.Assert(simpleObj != null);
return(NSObject.FromObject(simpleObj));
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(value);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
SecStatusCode eCode = KeyChainUtils.SetPasswordForUsername(
settingName,
stringValue,
m_serviceName,
m_secAccessible,
m_synchronizable);
if (eCode == SecStatusCode.Success)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"KeyChainSerializer.Save - success",
settingName);
}
else
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
"KeyChainSerializer.Save - error",
String.Format("Setting name is {0}. Error code is {1}",
settingName,
eCode));
}
// keychain error handling from Xamarin.Auth
// https://github.com/xamarin/Xamarin.Auth/blob/master/source/Core/Xamarin.Auth.XamarinIOS/AccountStore/KeyChainAccountStore.Aync.cs
if (eCode != SecStatusCode.Success)
{
StringBuilder sb = new StringBuilder("error = ");
sb.AppendLine("Could not save value to KeyChain: " + eCode);
sb.AppendLine("Add Empty Entitlements.plist ");
sb.AppendLine("File /+ New file /+ iOS /+ Entitlements.plist");
/*
* Error: Could not save account to KeyChain -- iOS 10 #128
* https://github.com/xamarin/Xamarin.Auth/issues/128
* https://bugzilla.xamarin.com/show_bug.cgi?id=43514
*/
if ((int)eCode == -34018)
{
// http://stackoverflow.com/questions/38456471/secitemadd-always-returns-error-34018-in-xcode-8-in-ios-10-simulator
// NOTE: code was not copy/pasted! That was iOS sample
sb.AppendLine("SecKeyChain.Add returned : " + eCode);
sb.AppendLine("1. Add Keychain Access Groups to the Entitlements file.");
sb.AppendLine("2. Turn on the Keychain Sharing switch in the Capabilities section in the app.");
}
string msg = sb.ToString();
throw new ExceptionForUser(new Exception(msg));
}
}
//------------------------------------------------------------------------------
IEnumerable <string> LoadDynamicSettingsOrderImpl(string settingsOrderFullName, ISettingsSerializer serializer, Type settingsType)
{
try
{
var inSettingInfo = new SettingInfo()
{
SettingName = settingsOrderFullName,
};
var settingsHelperData = new SettingsHelperData()
{
SerializersCache = new Dictionary <Type, KeyValuePair <ISettingsSerializer, bool> >(),
SerializersToSync = new OrderedSet <ISettingsSerializer>(),
};
var outSettingInfo = ProcessArbitraryDynamicSetting(inSettingInfo, SettingsEnumerationMode.Load, ref settingsHelperData);
SettingsHelper.SynchronizeSerializers(settingsHelperData.SerializersToSync);
if (outSettingInfo == null)
{
return(null);
}
var settingsNamesOrder = SettingsSerializerHelper.ConvertUsingTypeConverter <string>(outSettingInfo.SettingValue);
settingsNamesOrder = settingsNamesOrder.Trim();
var settingsOrderResult = new List <String>();
if (String.IsNullOrEmpty(settingsNamesOrder))
{
return(settingsOrderResult);
}
var parts = settingsNamesOrder.Split(',');
foreach (var settingName in parts)
{
var trimSettingName = settingName.Trim();
settingsOrderResult.Add(trimSettingName);
}
return(settingsOrderResult);
}
catch
{
// return null in case of any error
}
return(null);
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
var simpleObj = SettingsSerializerHelper.SimplifyObject(value);
var prefs = GetUserDefaults();
var nsValue = simpleObj.ToNSObject();
prefs[settingName] = nsValue;
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"UserDefaultsSerializer.Save - success",
String.Format("Setting name is {0}; Value is {1}",
settingName,
nsValue != null ? nsValue.ToString() : "null"));
}
//------------------------------------------------------------------------------
static public object CorrectSettingType(object originalValue, Type destinationType)
{
Debug.Assert(destinationType != null);
if (originalValue == null)
{
return(null);
}
if (destinationType == typeof(DateTime) && originalValue.GetType() == destinationType)
{
return(originalValue);
}
if (IsGenericNullable(destinationType))
{
destinationType = GetUnderlyingType(destinationType);
}
originalValue =
InternalConfiguration.PlatformHelper.ToUnderlyingObject(originalValue, destinationType);
String strValue = originalValue as String;
if (strValue != null && strValue.IsBase64String())
{
try
{
// try to deserialize string value to smthng else
originalValue = DeserializeToWrapperObjectValue(strValue);
return(originalValue);
}
catch (Polenter.Serialization.Core.DeserializingException)
{
}
catch (System.FormatException)
{
}
catch (System.IO.EndOfStreamException)
{
}
}
var result = SettingsSerializerHelper.ConvertUsingTypeConverter(destinationType, originalValue);
return(result);
}
//------------------------------------------------------------------------------
T GetSettingImpl <T>(string settingName, T defaultValue, bool useInternalDefaultValue)
{
lock (m_lockObject)
{
var fullSettingName = CorrectDynamicSettingName(settingName);
object settingValue = null;
DynamicSettingInfo dsi;
bool exists = m_dynamicSettings.TryGetValue(fullSettingName, out dsi);
if (exists)
{
settingValue = dsi.SettingValue;
try
{
T convertedSettingValue = SettingsSerializerHelper.CorrectSettingType <T>(settingValue);
return(convertedSettingValue);
}
catch (Exception exc)
{
var msg = String.Format("Dynamic setting '{0}' type conversion exception", settingName);
InternalConfiguration.PlatformHelper.Log(LogLevel.Warning, msg, exc);
}
}
if (useInternalDefaultValue)
{
if (m_dynamicSettingsDefaultValues == null)
{
var msg = String.Format("Set default value for setting '{0}'", settingName);
throw new KeyNotFoundException(msg);
}
object objDefaultValue = m_dynamicSettingsDefaultValues[fullSettingName];
defaultValue = SettingsSerializerHelper.CorrectSettingType <T>(objDefaultValue);
}
else
{
// in this case T defaultValue is valid value
}
return(defaultValue);
}
}
//------------------------------------------------------------------------------
public static object GetDefaultValue(SettingBaseAttribute attr, Type settingType)
{
object defaultValue = null;
try
{
if (attr != null && attr.DefaultValueInUse)
{
defaultValue = attr.Default;
if (defaultValue is DefaulValueMode)
{
var defaultValueMode = (DefaulValueMode)defaultValue;
switch (defaultValueMode)
{
case DefaulValueMode.TypeDefaultValue:
{
defaultValue = GetTypeDefaultValue(settingType);
break;
}
default:
{
throw new NotImplementedException("Unknown DefaultValueMode");
}
}
}
else
{
defaultValue = SettingsSerializerHelper.ConvertUsingTypeConverter(settingType, defaultValue);
}
}
else
{
defaultValue = GetTypeDefaultValue(settingType);
}
}
catch (Exception exc)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error, "GetDefaultValue exception", exc);
InternalConfiguration.PlatformHelper.Log(LogLevel.Info, "Use type default value instead");
defaultValue = GetTypeDefaultValue(settingType);
}
return(defaultValue);
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
settingName = SettingNamePrefix + settingName;
var simpleValue = SettingsSerializerHelper.SimplifyObject(value);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
var binaryData = Encoding.ASCII.GetBytes(stringValue);
var entropy = SettingsConfiguration.SecureSettingsAdditionalEntropy;
var encryptedData =
ProtectedData.Protect(binaryData, entropy, SettingsConfiguration.SecureSettingsScope);
string encryptedBase64StringData = Convert.ToBase64String(encryptedData);
m_Store.Save(settingName, attr, encryptedBase64StringData);
}
//------------------------------------------------------------------------------
static public Object SimplifyObject(Object obj)
{
Type type = null;
bool isEnum = false;
if (obj != null)
{
type = obj.GetType();
isEnum = type.GetTypeInfo().IsEnum;
}
if (type == typeof(Boolean) ||
type == typeof(Char) ||
type == typeof(SByte) ||
type == typeof(Byte) ||
type == typeof(Int16) ||
type == typeof(UInt16) ||
type == typeof(Int32) ||
type == typeof(UInt32) ||
type == typeof(Int64) ||
type == typeof(UInt64) ||
type == typeof(String) ||
isEnum
// this values will be saved with wrapper
//type == typeof(Single)
//type == typeof(Double)
//type == typeof(Decimal)
)
{
}
else if (type == typeof(DateTime))
{
obj = ((DateTime)obj).ToString("o", CultureInfo.InvariantCulture);
}
else
{
// in case if object is null, custom object or smthng else
// save it to string with wrapper
obj = SettingsSerializerHelper.SaveToStringWithWrapperObject(obj);
}
return(obj);
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(value);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
using (var stream = m_Store.OpenFile(settingName, FileMode.Create, FileAccess.Write))
{
using (var sw = new StreamWriter(stream))
{
sw.Write(stringValue);
}
}
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"IsolatedStorageSerializer.Save - success",
String.Format("setting is {0}, value is {1}",
settingName,
stringValue != null ? stringValue : "null"));
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
if (m_editor == null)
{
var prefs = GetSharedPreferences();
m_editor = prefs.Edit();
}
object saveValue = value;
if (value is bool)
{
m_editor.PutBoolean(settingName, (bool)value);
}
else if (value is int)
{
m_editor.PutInt(settingName, (int)value);
}
else if (value is long)
{
m_editor.PutLong(settingName, (long)value);
}
else if (value is float)
{
m_editor.PutFloat(settingName, (float)value);
}
else
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(value);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
saveValue = stringValue;
m_editor.PutString(settingName, stringValue);
}
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"SharedPreferencesSerializer.Save - success",
String.Format("Setting is {0}. Value is {1}",
settingName,
saveValue != null ? saveValue.ToString() : "null"));
}
//------------------------------------------------------------------------------
public void Save(string settingName, SettingBaseAttribute attr, object value)
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(value);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
bool status = m_keyChainUtils.SaveKey(settingName, stringValue);
if (status)
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Info,
"KeyChainSerializer.Save - success",
settingName);
}
else
{
InternalConfiguration.PlatformHelper.Log(LogLevel.Error,
"KeyChainSerializer.Save - error",
settingName);
}
}
//------------------------------------------------------------------------------
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);
}
//------------------------------------------------------------------------------
static public T CorrectSettingType <T>(object originalValue)
{
T result = (T)SettingsSerializerHelper.CorrectSettingType(originalValue, typeof(T));
return(result);
}
//------------------------------------------------------------------------------
public Tuple <object, Type, object> CorrectType(object value, Type destinationType, object defaultValue)
{
var objDestinationValue = SettingsSerializerHelper.CorrectSettingType(value, typeof(object));
return(Tuple.Create <object, Type, object>(objDestinationValue, typeof(object), null));
}