public HttpResponseMessage UpdatePreferenceCategory(PreferenceCategory updateRecord)
{
try
{
if (updateRecord == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
// Update the Preference Category record in the Azure SQL DB:
int preferenceCategoryResult = _preferenceCategoryWorker.UpdateCreate(updateRecord);
if (preferenceCategoryResult > 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
// Existed already:
else if (preferenceCategoryResult == 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
private void InitSummary(Preference p)
{
if (p is PreferenceCategory)
{
PreferenceCategory pCat = (PreferenceCategory)p;
for (int i = 0; i < pCat.PreferenceCount; i++)
{
InitSummary(pCat.GetPreference(i));
}
}
else
{
UpdatePrefSummary(p);
}
}
public override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
AddPreferencesFromResource(Resource.Xml.preferences);
for (int i = 0; i < PreferenceScreen.PreferenceCount; i++)
{
if (PreferenceScreen.GetPreference(i) is PreferenceCategory)
{
PreferenceCategory pc = (PreferenceCategory)PreferenceScreen.GetPreference(i);
if (pc.Title.ToString() == "Versions")
{
ISharedPreferences sp = PreferenceManager.SharedPreferences;
Preference p = pc.GetPreference(0);
p.Summary = sp.GetString("VERSIONNUMBERSCOPE", "SCOPE VERSION NOT FOUND");
Preference p2 = pc.GetPreference(1);
p2.Summary = sp.GetString("VERSIONNUMBERWIFI", "WIFI VERSION NOT FOUND");
Preference p3 = pc.GetPreference(2);
p3.Summary = sp.GetString("APPVERSION", "APP VERSION NOT FOUND");
}
if (pc.Title.ToString() == "Settings")
{
ISharedPreferences sp = PreferenceManager.SharedPreferences;
Preference p = pc.GetPreference(0);
p.Summary = sp.GetString("WIFINAME", "FAILED TO RETREIVE WIFINAME");
Preference p2 = pc.GetPreference(1);
}
if (pc.Title.ToString() == "Calibration")
{
ISharedPreferences sp = PreferenceManager.SharedPreferences;
Preference p = pc.GetPreference(0);
}
}
}
}
public override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
AddPreferencesFromResource(Resource.Xml.pref_general);
apiCategory = (PreferenceCategory)FindPreference(CATEGORY_API);
FindPreference(KEY_ABOUTAPP).PreferenceClick += (object sender, Preference.PreferenceClickEventArgs e) =>
{
// Display the fragment as the main content.
FragmentManager.BeginTransaction()
.Replace(Android.Resource.Id.Content, new AboutAppFragment())
.AddToBackStack(null)
.Commit();
};
followGps = (SwitchPreference)FindPreference(KEY_FOLLOWGPS);
followGps.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
SwitchPreference pref = e.Preference as SwitchPreference;
if ((bool)e.NewValue)
{
if (Activity.CheckSelfPermission(Manifest.Permission.AccessFineLocation) != Permission.Granted &&
Activity.CheckSelfPermission(Manifest.Permission.AccessCoarseLocation) != Permission.Granted)
{
RequestPermissions(new String[] { Manifest.Permission.AccessCoarseLocation, Manifest.Permission.AccessFineLocation },
PERMISSION_LOCATION_REQUEST_CODE);
return;
}
}
};
keyEntry = (KeyEntryPreference)FindPreference(KEY_APIKEY);
keyEntry.BeforeDialogCreated += (object sender, EventArgs e) =>
{
keyEntry?.UpdateAPI(providerPref.Value);
};
keyEntry.PositiveButtonClick += async(sender, e) =>
{
String key = keyEntry.APIKey;
String API = providerPref.Value;
if (await WeatherData.WeatherManager.IsKeyValid(key, API))
{
Settings.API_KEY = key;
Settings.API = API;
Settings.KeyVerified = true;
UpdateKeySummary();
keyEntry.Dialog.Dismiss();
}
};
personalKeyPref = (SwitchPreference)FindPreference(KEY_USEPERSONALKEY);
personalKeyPref.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as SwitchPreference;
if ((bool)e.NewValue)
{
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
keyEntry.Enabled = true;
}
else
{
var selectedWProv = WeatherData.WeatherManager.GetProvider(providerPref.Value);
if (!String.IsNullOrWhiteSpace(selectedWProv.GetAPIKey()))
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
Settings.API = providerPref.Value;
}
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
};
var providers = WeatherData.WeatherAPI.APIs;
providerPref = (ListPreference)FindPreference(KEY_API);
providerPref.SetEntries(providers.Select(provider => provider.Display).ToArray());
providerPref.SetEntryValues(providers.Select(provider => provider.Value).ToArray());
providerPref.Persistent = false;
providerPref.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as ListPreference;
var selectedWProv = WeatherData.WeatherManager.GetProvider(e.NewValue.ToString());
if (selectedWProv.KeyRequired)
{
if (String.IsNullOrWhiteSpace(selectedWProv.GetAPIKey()))
{
personalKeyPref.Checked = Settings.UsePersonalKey = true;
personalKeyPref.Enabled = false;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
personalKeyPref.Enabled = true;
}
if (!Settings.UsePersonalKey)
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
keyEntry.Enabled = true;
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
}
if (apiCategory.FindPreference(KEY_USEPERSONALKEY) == null)
{
apiCategory.AddPreference(personalKeyPref);
}
// Reset to old value if not verified
if (!Settings.KeyVerified)
{
Settings.API = pref.Value;
}
else
{
Settings.API = e.NewValue.ToString();
}
var providerEntry = providers.Find(provider => provider.Value == e.NewValue.ToString());
UpdateKeySummary(providerEntry.Display);
UpdateRegisterLink(providerEntry.Value);
}
else
{
Settings.KeyVerified = false;
keyEntry.Enabled = false;
personalKeyPref.Enabled = false;
Settings.API = e.NewValue.ToString();
// Clear API KEY entry to avoid issues
Settings.API_KEY = String.Empty;
apiCategory.RemovePreference(personalKeyPref);
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
UpdateKeySummary();
UpdateRegisterLink();
}
};
registerPref = FindPreference(KEY_APIREGISTER);
registerPref.PreferenceClick += RegisterPref_PreferenceClick;
// Set key as verified if API Key is req for API and its set
if (WeatherData.WeatherManager.GetInstance().KeyRequired)
{
keyEntry.Enabled = true;
if (!String.IsNullOrWhiteSpace(Settings.API_KEY) && !Settings.KeyVerified)
{
Settings.KeyVerified = true;
}
if (String.IsNullOrWhiteSpace(WeatherData.WeatherManager.GetInstance().GetAPIKey()))
{
personalKeyPref.Checked = Settings.UsePersonalKey = true;
personalKeyPref.Enabled = false;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
personalKeyPref.Enabled = true;
}
if (!Settings.UsePersonalKey)
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
keyEntry.Enabled = true;
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
}
}
else
{
keyEntry.Enabled = false;
personalKeyPref.Enabled = false;
apiCategory.RemovePreference(personalKeyPref);
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
Settings.KeyVerified = false;
}
UpdateKeySummary();
UpdateRegisterLink();
syncPreference = (ListPreference)FindPreference(KEY_DATASYNC);
syncPreference.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
int newValue = int.Parse(e.NewValue.ToString());
ListPreference pref = e.Preference as ListPreference;
pref.Summary = pref.GetEntries()[newValue];
EnableSyncedSettings((WearableDataSync)newValue == WearableDataSync.Off);
};
syncPreference.Summary = syncPreference.GetEntries()[int.Parse(syncPreference.Value)];
EnableSyncedSettings(Settings.DataSync == WearableDataSync.Off);
connStatusPref = FindPreference(KEY_CONNSTATUS);
connStatusReceiver = new ConnectionStatusReceiver();
connStatusReceiver.ConnectionStatusChanged += (status) =>
{
switch (status)
{
case WearConnectionStatus.Disconnected:
connStatusPref.Summary = GetString(Resource.String.status_disconnected);
connStatusPref.PreferenceClick -= ConnStatusPref_PreferenceClick;
break;
case WearConnectionStatus.Connecting:
connStatusPref.Summary = GetString(Resource.String.status_connecting);
connStatusPref.PreferenceClick -= ConnStatusPref_PreferenceClick;
break;
case WearConnectionStatus.AppNotInstalled:
connStatusPref.Summary = GetString(Resource.String.status_notinstalled);
connStatusPref.PreferenceClick += ConnStatusPref_PreferenceClick;
break;
case WearConnectionStatus.Connected:
connStatusPref.Summary = GetString(Resource.String.status_connected);
connStatusPref.PreferenceClick -= ConnStatusPref_PreferenceClick;
break;
default:
break;
}
};
}
protected override T OnBuildElement <T>(XElement element)
{
var category = new PreferenceCategory();
category.FriendlyName = XElementHelper.ReadStringValue(element, "friendlyName");
// Read the list of Preference tags
var foundPreferences = XElementHelper.ReadEnumerable(element, "preference");
// For each preference Tag, store the values into a new Preference object
foreach (var foundPreference in foundPreferences)
{
// Ugly way of reading shared properties without duplicating code.
Action <IPreference> readSharedProperties = preference =>
{
preference.Name = XElementHelper.ReadStringValue(foundPreference, "name");
preference.FriendlyName = XElementHelper.ReadStringValue(foundPreference, "friendlyName");
preference.Description = XElementHelper.ReadStringValue(foundPreference, "description", false);
preference.HasDirectlyEditableValue = XElementHelper.ReadBoolValue(foundPreference,
"hasDirectlyEditableValue", false);
preference.useCurlyBraces = XElementHelper.ReadBoolValue(foundPreference,
"useCurlyBraces", false);
preference.AllowMultipleSelections = XElementHelper.ReadBoolValue(foundPreference, "allowMultipleSelections", false);
category.Preferences.Add(preference);
};
// Determine preference type
var isDate = XElementHelper.ReadBoolValue(foundPreference, "isDate", false);
var isNumeric = XElementHelper.ReadBoolValue(foundPreference, "isNumeric", false);
var allowsMultipleSelections = XElementHelper.ReadBoolValue(foundPreference, "allowMultipleSelections", false);
if (isDate)
{
var preference = new DatePreference();
preference.DateFormat = XElementHelper.ReadStringValue(foundPreference, "dateFormat");
preference.MinValue = XElementHelper.ReadDateValue(foundPreference, "minDateValue",
preference.DateFormat, false);
preference.MaxValue = XElementHelper.ReadDateValue(foundPreference, "maxDateValue",
preference.DateFormat, false);
preference.Value = XElementHelper.ReadDateValue(foundPreference, "value", preference.DateFormat,
true);
// Read the list of entryOption tags
var foundEntries = XElementHelper.ReadEnumerable(foundPreference, "entryOption", false);
// For each tag, read the values into a new PreferenceEntry object
foreach (var entry in foundEntries)
{
preference.Entries.Add(BuildPreferenceEntry <IDatePreferenceEntry>(preference, entry));
}
readSharedProperties(preference);
}
else if (isNumeric)
{
var preference = new NumericPreference();
preference.MinValue = XElementHelper.ReadDoubleValue(foundPreference, "minValue", false);
preference.MaxValue = XElementHelper.ReadDoubleValue(foundPreference, "maxValue", false);
preference.Value = XElementHelper.ReadDoubleValue(foundPreference, "value", true);
// Read the list of entryOption tags
var foundEntries = XElementHelper.ReadEnumerable(foundPreference, "entryOption", false);
// For each tag, read the values into a new PreferenceEntry object
foreach (var entry in foundEntries)
{
preference.Entries.Add(BuildPreferenceEntry <INumericPreferenceEntry>(preference, entry));
}
readSharedProperties(preference);
}
else if (allowsMultipleSelections)
{
var preference = new StringListPreference();
//preference.MinValue = XElementHelper.ReadStringValue(foundPreference, "minValue", false);
//preference.MaxValue = XElementHelper.ReadStringValue(foundPreference, "maxValue", false);
//preference.Value = XElementHelper.ReadStringValue(foundPreference, "value", false);
// Read the list of entryOption tags
var foundEntries = XElementHelper.ReadEnumerable(foundPreference, "entryOption", false);
// For each tag, read the values into a new PreferenceEntry object
foreach (var entry in foundEntries)
{
preference.Entries.Add(BuildPreferenceEntry <IStringListPreferenceEntry>(preference, entry));
}
readSharedProperties(preference);
}
else
{
var preference = new StringPreference();
preference.MinValue = XElementHelper.ReadStringValue(foundPreference, "minValue", false);
preference.MaxValue = XElementHelper.ReadStringValue(foundPreference, "maxValue", false);
preference.Value = XElementHelper.ReadStringValue(foundPreference, "value", false);
// Read the list of entryOption tags
var foundEntries = XElementHelper.ReadEnumerable(foundPreference, "entryOption", false);
// For each tag, read the values into a new PreferenceEntry object
foreach (var entry in foundEntries)
{
preference.Entries.Add(BuildPreferenceEntry <IStringPreferenceEntry>(preference, entry));
}
readSharedProperties(preference);
}
}
return(category as T);
}
public override void OnCreate(Bundle savedInstanceState)
{
try
{
base.OnCreate(savedInstanceState);
AddPreferencesFromResource(Resource.Xml.SettingsPrefs);
Wo_Main_Settings.Shared_Data = PreferenceManager.SharedPreferences;
PreferenceCategory mCategory = (PreferenceCategory)FindPreference("category_General");
EditProfile = FindPreference("editprofile_key");
BlockedUsers = FindPreference("blocked_key");
Account_Pref = FindPreference("editAccount_key");
Password_Pref = FindPreference("editpassword_key");
General_Invite_Pref = FindPreference("invite_key");
General_Call_Pref = FindPreference("Call_key");
if (!AppSettings.Enable_Audio_Video_Call)
{
mCategory.RemovePreference(General_Call_Pref);
}
if (!AppSettings.Invitation_System)
{
mCategory.RemovePreference(General_Invite_Pref);
}
Support_Report_Pref = FindPreference("Report_key");
Support_Help_Pref = FindPreference("help_key");
Support_Logout_Pref = FindPreference("logout_key");
Support_deleteaccount_Pref = FindPreference("deleteaccount_key");
Lang_Pref = (ListPreference)FindPreference("Lang_key");
About_Me_Pref = (EditTextPreference)FindPreference("about_me_key");
//Privacy
Privacy_Follow_Pref = (ListPreference)FindPreference("whocanfollow_key");
Privacy_Message_Pref = (ListPreference)FindPreference("whocanMessage_key");
Privacy_Birthday_Pref = (ListPreference)FindPreference("whocanseemybirthday_key");
Notifcation_Popup_Pref = (SwitchPreference)FindPreference("notifications_key");
Notifcation_PlaySound_Pref = (CheckBoxPreference)FindPreference("checkBox_PlaySound_key");
//Add Click event to Preferences
EditProfile.Intent = new Intent(Application.Context, typeof(MyProfile_Activity));
BlockedUsers.Intent = new Intent(Application.Context, typeof(BlockedUsers_Activity));
Account_Pref.Intent = new Intent(Application.Context, typeof(My_Account_Activity));
Password_Pref.Intent = new Intent(Application.Context, typeof(Password_Activity));
General_Invite_Pref.Intent = new Intent(Application.Context, typeof(Invite_Friends_Activity));
//Update Preferences data on Load
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "about_me_key");
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "whocanfollow_key");
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "whocanMessage_key");
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "whocanseemybirthday_key");
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "notifications_key");
OnSharedPreferenceChanged(Wo_Main_Settings.Shared_Data, "checkBox_PlaySound_key");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public override void OnCreatePreferences(Bundle savedInstanceState, string rootKey)
{
SetPreferencesFromResource(Resource.Xml.pref_general, null);
HasOptionsMenu = false;
notCategory = (PreferenceCategory)FindPreference(CATEGORY_NOTIFICATION);
apiCategory = (PreferenceCategory)FindPreference(CATEGORY_API);
FindPreference(KEY_ABOUTAPP).PreferenceClick += (object sender, Preference.PreferenceClickEventArgs e) =>
{
// Display the fragment as the main content.
FragmentManager.BeginTransaction()
.Replace(Android.Resource.Id.Content, new AboutAppFragment())
.AddToBackStack(null)
.Commit();
};
followGps = (SwitchPreferenceCompat)FindPreference(KEY_FOLLOWGPS);
followGps.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as SwitchPreferenceCompat;
if ((bool)e.NewValue)
{
if (ContextCompat.CheckSelfPermission(Activity, Manifest.Permission.AccessFineLocation) != Permission.Granted &&
ContextCompat.CheckSelfPermission(Activity, Manifest.Permission.AccessCoarseLocation) != Permission.Granted)
{
ActivityCompat.RequestPermissions(this.Activity, new String[] { Manifest.Permission.AccessCoarseLocation, Manifest.Permission.AccessFineLocation },
PERMISSION_LOCATION_REQUEST_CODE);
return;
}
else
{
// Reset home location data
//Settings.SaveLastGPSLocData(new WeatherData.LocationData());
}
}
};
keyEntry = (EditTextPreference)FindPreference(KEY_APIKEY);
personalKeyPref = (SwitchPreferenceCompat)FindPreference(KEY_USEPERSONALKEY);
personalKeyPref.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as SwitchPreferenceCompat;
if ((bool)e.NewValue)
{
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
keyEntry.Enabled = true;
}
else
{
var selectedWProv = WeatherData.WeatherManager.GetProvider(providerPref.Value);
if (!String.IsNullOrWhiteSpace(selectedWProv.GetAPIKey()))
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
Settings.API = providerPref.Value;
}
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
};
var providers = WeatherData.WeatherAPI.APIs;
providerPref = (DropDownPreference)FindPreference(KEY_API);
providerPref.SetEntries(providers.Select(provider => provider.Display).ToArray());
providerPref.SetEntryValues(providers.Select(provider => provider.Value).ToArray());
providerPref.Persistent = false;
providerPref.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as ListPreference;
var selectedWProv = WeatherData.WeatherManager.GetProvider(e.NewValue.ToString());
if (selectedWProv.KeyRequired)
{
if (String.IsNullOrWhiteSpace(selectedWProv.GetAPIKey()))
{
personalKeyPref.Checked = Settings.UsePersonalKey = true;
personalKeyPref.Enabled = false;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
personalKeyPref.Enabled = true;
}
if (!Settings.UsePersonalKey)
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
keyEntry.Enabled = true;
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
}
if (apiCategory.FindPreference(KEY_USEPERSONALKEY) == null)
{
apiCategory.AddPreference(personalKeyPref);
}
// Reset to old value if not verified
if (!Settings.KeyVerified)
{
Settings.API = pref.Value;
}
else
{
Settings.API = e.NewValue.ToString();
}
var providerEntry = providers.Find(provider => provider.Value == e.NewValue.ToString());
UpdateKeySummary(providerEntry.Display);
UpdateRegisterLink(providerEntry.Value);
}
else
{
Settings.KeyVerified = false;
keyEntry.Enabled = false;
personalKeyPref.Enabled = false;
Settings.API = e.NewValue.ToString();
// Clear API KEY entry to avoid issues
Settings.API_KEY = String.Empty;
apiCategory.RemovePreference(personalKeyPref);
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
UpdateKeySummary();
UpdateRegisterLink();
}
UpdateAlertPreference(WeatherData.WeatherManager.GetInstance().SupportsAlerts);
};
registerPref = FindPreference(KEY_APIREGISTER);
// Set key as verified if API Key is req for API and its set
if (WeatherData.WeatherManager.GetInstance().KeyRequired)
{
keyEntry.Enabled = true;
if (!String.IsNullOrWhiteSpace(Settings.API_KEY) && !Settings.KeyVerified)
{
Settings.KeyVerified = true;
}
if (String.IsNullOrWhiteSpace(WeatherData.WeatherManager.GetInstance().GetAPIKey()))
{
personalKeyPref.Checked = Settings.UsePersonalKey = true;
personalKeyPref.Enabled = false;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
personalKeyPref.Enabled = true;
}
if (!Settings.UsePersonalKey)
{
// We're using our own (verified) keys
Settings.KeyVerified = true;
keyEntry.Enabled = false;
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
}
else
{
keyEntry.Enabled = true;
if (apiCategory.FindPreference(KEY_APIKEY) == null)
{
apiCategory.AddPreference(keyEntry);
}
if (apiCategory.FindPreference(KEY_APIREGISTER) == null)
{
apiCategory.AddPreference(registerPref);
}
}
}
else
{
keyEntry.Enabled = false;
personalKeyPref.Enabled = false;
apiCategory.RemovePreference(personalKeyPref);
apiCategory.RemovePreference(keyEntry);
apiCategory.RemovePreference(registerPref);
Settings.KeyVerified = false;
}
UpdateKeySummary();
UpdateRegisterLink();
onGoingNotification = (SwitchPreferenceCompat)FindPreference(KEY_ONGOINGNOTIFICATION);
onGoingNotification.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as SwitchPreferenceCompat;
var context = App.Context;
// On-going notification
if ((bool)e.NewValue)
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REFRESHNOTIFICATION));
if (notCategory.FindPreference(KEY_NOTIFICATIONICON) == null)
{
notCategory.AddPreference(notificationIcon);
}
}
else
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REMOVENOTIFICATION));
notCategory.RemovePreference(notificationIcon);
}
};
notificationIcon = (DropDownPreference)FindPreference(KEY_NOTIFICATIONICON);
notificationIcon.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var context = App.Context;
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REFRESHNOTIFICATION));
};
// Remove preferences
if (!onGoingNotification.Checked)
{
notCategory.RemovePreference(notificationIcon);
}
alertNotification = (SwitchPreferenceCompat)FindPreference(KEY_USEALERTS);
alertNotification.PreferenceChange += (object sender, Preference.PreferenceChangeEventArgs e) =>
{
var pref = e.Preference as SwitchPreferenceCompat;
var context = App.Context;
// Alert notification
if ((bool)e.NewValue)
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_STARTALARM));
}
else
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_CANCELALARM));
}
};
UpdateAlertPreference(WeatherData.WeatherManager.GetInstance().SupportsAlerts);
}
/// <summary>
/// Reads the category configuration.
/// </summary>
/// <returns></returns>
private IList <PreferenceCategory> ReadCategoryConfig()
{
var categories = new List <PreferenceCategory>();
var configFileName = "Configuration.xml";
var config = XmlHelper.ReadXmlFile(configFileName);
if (config == null)
{
return(null);
}
try
{
// Read the list of categories from the xml
var foundCategories = config.Descendants("category");
// For each category, store the values in a new PreferenceCategory object.
foreach (var foundCategory in foundCategories)
{
var category = new PreferenceCategory();
category.FriendlyName = XElementHelper.ReadStringValue(foundCategory, "friendlyName");
categories.Add(category);
// Read the list of Preference tags
var foundPreferences = XElementHelper.ReadEnumerable(foundCategory, "preference");
// For each preference Tag, store the values into a new Preference object
foreach (var foundPreference in foundPreferences)
{
IPreference preference = new Preference();
preference.Name = XElementHelper.ReadStringValue(foundPreference, "name");
preference.FriendlyName = XElementHelper.ReadStringValue(foundPreference, "friendlyName");
preference.Description = XElementHelper.ReadStringValue(foundPreference, "description", false);
preference.MinValue = XElementHelper.ReadDoubleValue(foundPreference, "minValue", false);
preference.MaxValue = XElementHelper.ReadDoubleValue(foundPreference, "maxValue", false);
preference.Value = XElementHelper.ReadStringValue(foundPreference, "value", false);
preference.HasDirectlyEditableValue = XElementHelper.ReadBoolValue(foundPreference, "hasDirectlyEditableValue", false);
category.Preferences.Add(preference);
// Read the list of entryOption tags
var foundEntries = XElementHelper.ReadEnumerable(foundPreference, "entryOption", false);
// For each tag, read the values into a new PreferenceEntry object
foreach (var entry in foundEntries)
{
preference.Entries.Add(this.BuildPreferenceEntry(preference, entry));
}
}
}
}
////catch (MissingRequiredXMLPropertyException ex)
////{
////}
////catch (MalformedXMLException ex)
////{
////}
////catch (UnParsableDataValueException ex)
////{
////}
catch (XMLParseExceptionBase ex)
{
this.ShowMalformedOrMissingXMLElementError(configFileName, ex);
}
catch (Exception ex)
{
this.options.Logger.AddLogEntry(new LogEntry(ex.Message + " - " + ex.InnerException, LogEntrySeverity.Error, LogEntrySource.UI));
}
return(categories);
}
private void InitComponent()
{
try
{
SharedPref.SharedData = PreferenceManager.SharedPreferences;
PreferenceManager.SharedPreferences.RegisterOnSharedPreferenceChangeListener(this);
GeneralPref = FindPreference("general_key");
MyAccountPref = FindPreference("myAccount_key");
PasswordPref = FindPreference("editPassword_key");
BlockedUsersPref = FindPreference("blocked_key");
NightMode = (ListPreference)FindPreference("Night_Mode_key");
InterestPref = FindPreference("interest_key");
HelpPref = FindPreference("help_key");
AboutPref = FindPreference("about_key");
DeleteAccountPref = FindPreference("deleteAccount_key");
LogoutPref = FindPreference("logout_key");
GoProPref = FindPreference("goPro_key");
WithdrawalsPref = FindPreference("Withdrawals_key");
OnSharedPreferenceChanged(SharedPref.SharedData, "Night_Mode_key");
PreferenceCategory mCategoryAccount = (PreferenceCategory)FindPreference("Account_Profile_key");
if (!AppSettings.ShowEditPassword)
{
mCategoryAccount.RemovePreference(PasswordPref);
}
if (!AppSettings.ShowWithdrawals)
{
mCategoryAccount.RemovePreference(WithdrawalsPref);
}
if (!AppSettings.ShowGoPro)
{
mCategoryAccount.RemovePreference(GoProPref);
}
if (!AppSettings.ShowBlockedUsers)
{
mCategoryAccount.RemovePreference(BlockedUsersPref);
}
GeneralPref.PreferenceClick += GeneralPrefOnPreferenceClick;
MyAccountPref.PreferenceClick += MyAccountPrefOnPreferenceClick;
PasswordPref.PreferenceClick += PasswordPrefOnPreferenceClick;
BlockedUsersPref.PreferenceClick += BlockedUsersPrefOnPreferenceClick;
InterestPref.PreferenceClick += InterestPrefOnPreferenceClick;
HelpPref.PreferenceClick += HelpPrefOnPreferenceClick;
AboutPref.PreferenceClick += AboutPrefOnPreferenceClick;
DeleteAccountPref.PreferenceClick += DeleteAccountPrefOnPreferenceClick;
LogoutPref.PreferenceClick += LogoutPrefOnPreferenceClick;
GoProPref.PreferenceClick += GoProPrefOnPreferenceClick;
WithdrawalsPref.PreferenceClick += WithdrawalsPrefOnPreferenceClick;
NightMode.PreferenceChange += NightModeOnPreferenceChange;
NightMode.IconSpaceReserved = false;
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private void InitComponent()
{
try
{
SharedPref.SharedData = PreferenceManager.SharedPreferences;
PreferenceManager.SharedPreferences.RegisterOnSharedPreferenceChangeListener(this);
GeneralPref = FindPreference("general_key");
MyAccountPref = FindPreference("myAccount_key");
ArticlePref = FindPreference("article_key");
PasswordPref = FindPreference("editPassword_key");
BlockedUsersPref = FindPreference("blocked_key");
TwoFactorPref = FindPreference("Twofactor_key");
ManageSessionsPref = FindPreference("ManageSessions_key");
NightMode = FindPreference("Night_Mode_key");
InterestPref = FindPreference("interest_key");
HelpPref = FindPreference("help_key");
AboutPref = FindPreference("about_key");
DeleteAccountPref = FindPreference("deleteAccount_key");
LogoutPref = FindPreference("logout_key");
GoProPref = FindPreference("goPro_key");
WithdrawalsPref = FindPreference("Withdrawals_key");
OnSharedPreferenceChanged(SharedPref.SharedData, "Night_Mode_key");
//Delete Preference
//============== Account_Profile_key ===================
PreferenceCategory mCategoryAccount = (PreferenceCategory)FindPreference("Account_Profile_key");
if (!AppSettings.ShowWithdrawals)
{
mCategoryAccount.RemovePreference(WithdrawalsPref);
}
if (!AppSettings.ShowGoPro)
{
mCategoryAccount.RemovePreference(GoProPref);
}
if (!AppSettings.ShowBlog)
{
mCategoryAccount.RemovePreference(ArticlePref);
}
if (!AppSettings.ShowBlockedUsers)
{
mCategoryAccount.RemovePreference(BlockedUsersPref);
}
//============== SecurityAccount_key ===================
var mCategorySecurity = (PreferenceCategory)FindPreference("SecurityAccount_key");
if (!AppSettings.ShowEditPassword)
{
mCategorySecurity.RemovePreference(PasswordPref);
}
if (!AppSettings.ShowSettingsTwoFactor)
{
mCategorySecurity.RemovePreference(TwoFactorPref);
}
if (!AppSettings.ShowSettingsManageSessions)
{
mCategorySecurity.RemovePreference(ManageSessionsPref);
}
NightMode.IconSpaceReserved = false;
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PreferencesViewModel"/> class.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="view">The view.</param>
/// <param name="category">The category.</param>
public PreferencesViewModel(ConverterOptions options, IView view, PreferenceCategory category)
: base(view, category.FriendlyName, options)
{
this.Category = category;
}
private void SetDownloadSettings()
{
_PinCategory = (PreferenceCategory)this.FindPreference("Pin");
_PinEnable = (SwitchPreference)this.FindPreference("PinActive");
_DownCategory = (PreferenceCategory)this.FindPreference("Download");
_DownEnable = (SwitchPreference)this.FindPreference("DownActive");
_DownUser = (Preference)this.FindPreference("DownUsername");
_DownLogout = (Preference)this.FindPreference("DownLogout");
_DownReset = (Preference)this.FindPreference("DownReset");
_NotifyCategory = (PreferenceCategory)this.FindPreference("Notifications");
_NotifyTest = (Preference)this.FindPreference("NotTest");
//pin
_PinCategory.Title = GetString(Resource.String.set_pin);
//_PinEnable.WidgetLayoutResource = Resource.Layout.CustomSwitch;
if (DataManager.Get <ISettingsManager>().Settings.PinEnabled)
{
_PinEnable.Title = GetString(Resource.String.set_pinEnabled);
_PinEnable.Checked = DataManager.Get <IPreferencesManager>().Preferences.PinEnabled;
_PinEnable.PreferenceChange += (sender, e) =>
{
if (_PinEnable.Checked != (bool)e.NewValue)
{
ShowPinDialog((bool)e.NewValue);
}
};
}
else
{
_PinCategory.RemovePreference(_PinEnable);
_PinCategory.Enabled = false;
_PinCategory.ShouldDisableView = true;
_PinCategory.Title = "";
}
//download
//_DownEnable.WidgetLayoutResource = Resource.Layout.CustomSwitch;
_DownEnable.Title = GetString(Resource.String.set_downEnabled);
_DownEnable.Checked = DataManager.Get <IPreferencesManager>().Preferences.DownloadEnabled;
_DownEnable.PreferenceChange += (sender, e) =>
{
DataManager.Get <IPreferencesManager>().Preferences.DownloadEnabled = (bool)e.NewValue;
DataManager.Get <IPreferencesManager>().Save();
_DownUser.Enabled = (bool)e.NewValue;
_DownLogout.Enabled = (bool)e.NewValue;
_DownReset.Enabled = (bool)e.NewValue;
};
//in base al tipo di login setto le impostazioni disponibili
if (DataManager.Get <ISettingsManager>().Settings.DownloadUtenti || DataManager.Get <ISettingsManager>().Settings.DownloadPassword)
{
if (DownloadManager.IsLogged())
{
if (DataManager.Get <ISettingsManager>().Settings.DownloadUtenti)
{
_DownUser.Summary = DataManager.Get <IPreferencesManager>().Preferences.DownloadUsername;
}
else
{
_DownUser.Summary = GetString(Resource.String.set_logged);
}
_DownCategory.RemovePreference(_DownReset);
}
else
{
_DownUser.Summary = GetString(Resource.String.set_notLogged);
_DownCategory.RemovePreference(_DownLogout);
}
//attivo il popup per il login
_DownUser.PreferenceClick += (sender, e) =>
{
ShowLoginDialog();
};
}
else
{
_DownCategory.RemovePreference(_DownUser);
}
//pulsante logout
if (DataManager.Get <ISettingsManager>().Settings.DownloadUtenti || DataManager.Get <ISettingsManager>().Settings.DownloadPassword)
{
_DownLogout.Title = GetString(Resource.String.set_logout);
_DownLogout.Summary = GetString(Resource.String.set_publicAccess);
_DownLogout.PreferenceClick += (sender, e) =>
{
var dialog = new AlertDialog.Builder(Activity);
dialog.SetTitle(_DownCategory.Title);
dialog.SetMessage(GetString(Resource.String.set_logoutConfirm));
dialog.SetNegativeButton(GetString(Resource.String.gen_cancel), delegate
{
return;
});
dialog.SetPositiveButton(GetString(Resource.String.set_logout), delegate
{
DataManager.Get <IPreferencesManager>().Preferences.DownloadUsername = "";
DataManager.Get <IPreferencesManager>().Preferences.DownloadPassword = "";
DataManager.Get <IPreferencesManager>().Save();
_DownUser.Summary = GetString(Resource.String.set_notLogged);
_DownCategory.RemovePreference(_DownLogout);
if (DataManager.Get <ISettingsManager>().Settings.DownloadUtenti&& DataManager.Get <ISettingsManager>().Settings.PasswordReset)
{
_DownCategory.AddPreference(_DownReset);
}
});
dialog.Create();
dialog.Show().SetDivider();
};
}
else
{
_DownCategory.RemovePreference(_DownLogout);
}
//reset password
if (DataManager.Get <ISettingsManager>().Settings.PasswordReset)
{
if (DataManager.Get <ISettingsManager>().Settings.DownloadUtenti)
{
_DownReset.Title = GetString(Resource.String.set_forgot);
_DownReset.Summary = GetString(Resource.String.set_reset);
_DownReset.PreferenceClick += (sender, e) =>
{
ShowResetDialog();
};
}
}
else
{
_DownCategory.RemovePreference(_DownReset);
}
//notifiche
if (!Utility.IsMediabookApp)
{
_NotifyCategory.RemovePreference(_NotifyTest);
_NotifyCategory.Enabled = false;
_NotifyCategory.ShouldDisableView = true;
_NotifyCategory.Title = "";
}
else
{
_NotifyTest.PreferenceClick += (sender, e) =>
{
Notification noti = new Notification();
noti.SendTest(Activity.BaseContext.DeviceInfo(), "Notifica di esempio");
};
}
}
public override void OnCreatePreferences(Bundle savedInstanceState, string rootKey)
{
try
{
AddPreferencesFromResource(Resource.Xml.SettingsPrefs);
MainSettings.SharedData = PreferenceManager.SharedPreferences;
EditChannel = FindPreference("editChannal_key");
EditPassword = FindPreference("editPassword_key");
Monetization = FindPreference("monetization_key");
Verification = FindPreference("verification_key");
GoPro = FindPreference("goPro_key");
TwoFactorPref = FindPreference("Twofactor_key");
ManageSessionsPref = FindPreference("ManageSessions_key");
BlockedUsersPref = FindPreference("blocked_key");
PictureInPicturePerf = (SwitchPreferenceCompat)FindPreference("picture_in_picture_key");
ClaerHistory = FindPreference("ClaerHistory_key");
ClearCache = FindPreference("Clear_Cache_key");
//Lang = (ListPreference)FindPreference("Lang_key");
NightMode = FindPreference("Night_Mode_key");
Help = FindPreference("help_key");
Termsofuse = FindPreference("Termsofuse_key");
About = FindPreference("About_key");
DeleteAccount = FindPreference("deleteaccount_key");
Logout = FindPreference("logout_key");
OnSharedPreferenceChanged(MainSettings.SharedData, "Night_Mode_key");
//Delete Preference
//============== Account_Profile_key ===================
var mCategoryAccount = (PreferenceCategory)FindPreference("Account_Profile_key");
if (!AppSettings.ShowMonetization)
{
mCategoryAccount.RemovePreference(Monetization);
}
var isPro = ListUtils.MyChannelList.FirstOrDefault()?.IsPro ?? "0";
if (!AppSettings.ShowGoPro || isPro != "0")
{
mCategoryAccount.RemovePreference(GoPro);
}
if (!AppSettings.ShowVerification)
{
mCategoryAccount.RemovePreference(Verification);
}
if (!AppSettings.ShowBlockedUsers)
{
mCategoryAccount.RemovePreference(BlockedUsersPref);
}
//============== SecurityAccount_key ===================
var mCategorySecurity = (PreferenceCategory)FindPreference("SecurityAccount_key");
if (!AppSettings.ShowEditPassword)
{
mCategorySecurity.RemovePreference(EditPassword);
}
if (!AppSettings.ShowSettingsTwoFactor)
{
mCategorySecurity.RemovePreference(TwoFactorPref);
}
if (!AppSettings.ShowSettingsManageSessions)
{
mCategorySecurity.RemovePreference(ManageSessionsPref);
}
//============== CategoryGeneral_key ===================
PreferenceCategory mCategoryGeneral = (PreferenceCategory)FindPreference("CategoryGeneral_key");
if ((int)Build.VERSION.SdkInt <= 23)
{
mCategoryGeneral.RemovePreference(PictureInPicturePerf);
}
//============== History_Privacy_key ===================
PreferenceCategory mHistoryPrivacy = (PreferenceCategory)FindPreference("History_Privacy_key");
if (!AppSettings.ShowClearHistory)
{
mHistoryPrivacy.RemovePreference(ClaerHistory);
}
if (!AppSettings.ShowClearCache)
{
mHistoryPrivacy.RemovePreference(ClearCache);
}
//============== Support_key ===================
PreferenceCategory mCategorySupport = (PreferenceCategory)FindPreference("Support_key");
if (!AppSettings.ShowHelp)
{
mCategorySupport.RemovePreference(Help);
}
if (!AppSettings.ShowTermsOfUse)
{
mCategorySupport.RemovePreference(Termsofuse);
}
if (!AppSettings.ShowAbout)
{
mCategorySupport.RemovePreference(About);
}
if (!AppSettings.ShowDeleteAccount)
{
mCategorySupport.RemovePreference(DeleteAccount);
}
NightMode.IconSpaceReserved = false;
PictureInPicturePerf.IconSpaceReserved = false;
PictureInPicturePerf.Checked = UserDetails.PipIsChecked;
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
