//------------------------------------------------------------------------------
public static object MakeDynamicSetting(SettingInfo inSettingInfo)
{
var simpleValue = SettingsSerializerHelper.SimplifyObject(inSettingInfo.SettingValue);
var stringValue = SettingsSerializerHelper.ConvertUsingTypeConverter <String>(simpleValue);
return(stringValue);
}
//------------------------------------------------------------------------------
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);
}
//------------------------------------------------------------------------------
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);
}
//------------------------------------------------------------------------------
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);
}
//------------------------------------------------------------------------------
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)
{
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);
}