protected override object NativeGet(Type type, string key)
{
//type = type.Unwrap();
if (type == typeof(string))
{
return(Preference.Get <string>(key));
}
if (type == typeof(long))
{
return(Preference.Get <long>(key));
}
if (type == typeof(int))
{
return(Preference.Get <int>(key));
}
if (type == typeof(bool))
{
return(Preference.Get <bool>(key));
}
throw new ArgumentException("Invalid Type - " + type.FullName);
}
public T Get <T>(string key, T defaultValue, string sharedName)
{
lock (locker)
{
var value = defaultValue;
var fullKey = GetFullKey(key, sharedName);
if (Preference.Contains(fullKey))
{
switch (defaultValue)
{
case int i:
case bool b:
case long l:
case double d:
case float f:
case string s:
value = Preference.Get <T>(fullKey);
break;
default:
// the case when the string is null
if (typeof(T) == typeof(string))
{
value = (T)(object)Preference.Get <string>(fullKey);
}
break;
}
}
return(value);
}
}
public bool GetRecordOnResume()
{
if (Preference.Contains("record_on_resume"))
{
return(Preference.Get <bool>("record_on_resume"));
}
return(false);
}
public bool GetRecordOnStart()
{
if (Preference.Contains("record_on_start"))
{
return(Preference.Get <bool>("record_on_start"));
}
return(false);
}
public bool GetVibrateFeedback()
{
if (Preference.Contains("vibrate_feedback"))
{
return(Preference.Get <bool>("vibrate_feedback"));
}
return(true);
}
public bool GetLargerFont()
{
if (Preference.Contains("larger_font"))
{
return(Preference.Get <bool>("larger_font"));
}
return(false);
}
public bool GetHtmlResponse()
{
if (Preference.Contains("html_response"))
{
return(Preference.Get <bool>("html_response"));
}
return(false);
}
public bool GetSoundFeedback()
{
if (Preference.Contains("sound_feedback"))
{
return(Preference.Get <bool>("sound_feedback"));
}
return(true);
}
public bool GetRawVoiceRecognitionText()
{
if (Preference.Contains("raw_voice_recognition"))
{
return(Preference.Get <bool>("raw_voice_recognition"));
}
return(true);
}
public override T Get <T>(string key, T defaultValue = default)
{
if (!Preference.Contains(key))
{
return(defaultValue);
}
return(Preference.Get <T>(key));
}
protected override IDictionary <string, string> NativeValues()
{
var dict = new Dictionary <string, string>(Preference.Keys.Count());
foreach (var key in Preference.Keys)
{
var value = Preference.Get <object>(key);
dict.Add(key, value.ToString());
}
return(dict);
}
/// <summary>
/// Get value for the specific key
/// </summary>
/// <param name="key">key string</param>
/// <returns>value string</returns>
public string GetValue(string key)
{
lock (_locker)
{
try
{
return(Preference.Get <string>(key));
}
catch (Exception ex)
{
Console.WriteLine("[Preference.GetValue] key : " + key + ", exception:" + ex.Message);
return(null);
}
}
}
public static void Save(Preference P, string FileName)
{
var X = new XmlSave(FileName);
X.StartXML("preferences");
foreach (var ID in P.ID)
{
X.StartTag("pref");
X.Attribute("id", ID);
X.Attribute("value", P.Get(ID));
X.EndTag();
}
X.EndXML();
X.Close();
}
public void LoadInfo()
{
tokenData = new GoogleTokenData();
if (!Preference.Contains("access_token") || !Preference.Contains("refresh_token") ||
!Preference.Contains("issued_date") || !Preference.Contains("expires"))
{
isLoggedIn = false;
return;
}
tokenData.access_token = Preference.Get <string>("access_token");
tokenData.refresh_token = Preference.Get <string>("refresh_token");
tokenData.issued_date = DateTime.ParseExact(Preference.Get <string>("issued_date"), "yyyy-MM-dd HH:mm:ss", null);
tokenData.expires_in = Preference.Get <int>("expires");
isLoggedIn = true;
}
public static Task <List <Dialog>?> GetDialogs()
{
if (Preference.Contains(DialogsCacheKey))
{
try
{
var json = Preference.Get <string>(DialogsCacheKey);
var result = JsonConvert.DeserializeObject <List <Dialog> >(json);
return(Task.FromResult <List <Dialog>?>(result));
}
catch (Exception e)
{
Logger.Error(e);
}
}
return(Task.FromResult <List <Dialog>?>(null));
}
public DeviceInformation()
{
// Check whether STT feature is supported or not
Information.TryGetValue(Features.STT, out isSpeechRecognitionSupported);
// Check whether mic is available or not
Information.TryGetValue(Features.Microphone, out isMicrophoneSupported);
isFeatureSupported = isSpeechRecognitionSupported && isMicrophoneSupported;
bool existing = Preference.Contains(LastUsedID);
if (existing)
{
_numbering = Preference.Get <int>(LastUsedID);
}
else
{
_numbering = 0;
}
}
/// <summary>
/// Returns a value that indicates whether a specified key exists in the <see cref="ApplicationDataContainerSettings"/>.
/// If an item with that key exists, the item is retrieved as an out parameter.
/// </summary>
/// <param name="key">The key to check for in the <see cref="ApplicationDataContainerSettings"/>.</param>
/// <param name="value">The item, if it exists.
/// Contains null if the item does not exist in the <see cref="ApplicationDataContainerSettings"/>.</param>
/// <returns>true if an item with that key exists in the <see cref="ApplicationDataContainerSettings"/>; otherwise, false.</returns>
public bool TryGetValue(string key, out object value)
{
#if WINDOWS_UWP || WINDOWS_APP || WINDOWS_PHONE_APP || WINDOWS_PHONE_81
return(_settings.TryGetValue(key, out value));
#elif __ANDROID__ || WINDOWS_PHONE || __UNIFIED__
return(DoTryGetValue(key, out value));
#elif TIZEN
try
{
value = Preference.Get <object>(key);
return(value != null);
}
catch
{
value = null;
return(false);
}
#else
throw new PlatformNotSupportedException();
#endif
}
public Task <T> GetDataAsync <T>(string key)
{
try
{
if (Preference.Contains(key))
{
var json = Preference.Get <string>(key);
var data = JsonConvert.DeserializeObject <T>(json);
LogUtil.Debug($"Found cached data for {key}");
return(Task.FromResult(data));
}
else
{
LogUtil.Debug($"Missed cached data for {key}");
return(Task.FromResult(default(T)));
}
}
catch (Exception)
{
return(Task.FromResult(default(T)));
}
}
T GetValueOrDefaultInternal <T>(string key, T defaultValue = default(T), string fileName = null)
{
lock (locker)
{
var prefkey = GetFullPrefKey(key, fileName);
if (!Preference.Contains(prefkey))
{
return(defaultValue);
}
Type typeOf = typeof(T);
if (typeOf.GetTypeInfo().IsGenericType&& typeOf.GetGenericTypeDefinition() == typeof(Nullable <>))
{
typeOf = Nullable.GetUnderlyingType(typeOf);
}
object value = null;
var typeCode = Type.GetTypeCode(typeOf);
switch (typeCode)
{
case TypeCode.Decimal:
var savedDecimal = Preference.Get <string>(prefkey);
value = Convert.ToDecimal(savedDecimal, System.Globalization.CultureInfo.InvariantCulture);
break;
case TypeCode.Boolean:
value = Preference.Get <bool>(prefkey);
break;
case TypeCode.Int64:
var savedInt64 = Preference.Get <string>(prefkey);
value = Convert.ToInt64(savedInt64, System.Globalization.CultureInfo.InvariantCulture);
break;
case TypeCode.Double:
value = Preference.Get <double>(prefkey);
break;
case TypeCode.String:
value = Preference.Get <string>(prefkey);
break;
case TypeCode.Int32:
value = Preference.Get <int>(prefkey);
break;
case TypeCode.Single:
var savedSingle = Preference.Get <string>(prefkey);
value = Convert.ToSingle(savedSingle, System.Globalization.CultureInfo.InvariantCulture);
break;
case TypeCode.DateTime:
var savedTime = Preference.Get <string>(prefkey);
if (string.IsNullOrWhiteSpace(savedTime))
{
value = defaultValue;
}
else
{
var ticks = Convert.ToInt64(savedTime, System.Globalization.CultureInfo.InvariantCulture);
if (ticks >= 0)
{
//Old value, stored before update to UTC values
value = new DateTime(ticks);
}
else
{
//New value, UTC
value = new DateTime(-ticks, DateTimeKind.Utc);
}
}
break;
default:
if (defaultValue is Guid)
{
var outGuid = Guid.Empty;
var savedGuid = Preference.Get <string>(prefkey);
if (string.IsNullOrWhiteSpace(savedGuid))
{
value = outGuid;
}
else
{
Guid.TryParse(savedGuid, out outGuid);
value = outGuid;
}
}
else
{
throw new ArgumentException($"Value of type {typeCode} is not supported.");
}
break;
}
return(null != value ? (T)value : defaultValue);
}
}