private void ToggleEditMode()
{
// Toggle EditMode
EditMode = !EditMode;
IMenuItem editMenuBtn = optionsMenu.FindItem(Resource.Id.action_editmode);
// Change EditMode button drwble
editMenuBtn.SetIcon(EditMode ? Resource.Drawable.ic_done_white_24dp : Resource.Drawable.ic_mode_edit_white_24dp);
// Change EditMode button label
editMenuBtn.SetTitle(EditMode ? GetString(Resource.String.abc_action_mode_done) : GetString(Resource.String.action_editmode));
// Set Drag & Swipe ability
mITHCallback.SetLongPressDragEnabled(EditMode);
mITHCallback.SetItemViewSwipeEnabled(EditMode);
if (EditMode)
{
// Unregister events
gpsPanel.Click -= OnPanelClick;
mAdapter.ItemClick -= OnPanelClick;
mAdapter.ItemLongClick -= OnPanelLongClick;
}
else
{
// Register events
gpsPanel.Click += OnPanelClick;
mAdapter.ItemClick += OnPanelClick;
mAdapter.ItemLongClick += OnPanelLongClick;
}
foreach (LocationPanelViewModel view in mAdapter.Dataset)
{
view.EditMode = EditMode;
mAdapter.NotifyItemChanged(mAdapter.Dataset.IndexOf(view));
if (!EditMode && DataChanged)
{
string query = view.LocationData.query;
int pos = mAdapter.Dataset.IndexOf(view);
Task.Factory.StartNew(() => Settings.MoveLocation(query, pos));
}
}
if (!EditMode && HomeChanged)
{
WeatherWidgetService.EnqueueWork(AppCompatActivity, new Intent(AppCompatActivity, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
App.Context.StartService(
new Intent(App.Context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDLOCATIONUPDATE));
App.Context.StartService(
new Intent(App.Context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDWEATHERUPDATE));
}
DataChanged = false;
HomeChanged = false;
}
public override void OnReceive(Context context, Intent intent)
{
string action = intent?.Action;
if (Intent.ActionTimeChanged.Equals(action) ||
Intent.ActionTimezoneChanged.Equals(action))
{
// Update clock widget
var appWidgetManager = AppWidgetManager.GetInstance(context);
var componentname = new ComponentName(context.PackageName, ClassName);
int[] appWidgetIds = appWidgetManager.GetAppWidgetIds(componentname);
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATECLOCK)
.PutExtra(EXTRA_WIDGET_IDS, appWidgetIds)
.PutExtra(EXTRA_WIDGET_TYPE, (int)WidgetType));
}
else if (Intent.ActionDateChanged.Equals(action))
{
// Update clock widget
var appWidgetManager = AppWidgetManager.GetInstance(context);
var componentname = new ComponentName(context.PackageName, ClassName);
int[] appWidgetIds = appWidgetManager.GetAppWidgetIds(componentname);
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEDATE)
.PutExtra(EXTRA_WIDGET_IDS, appWidgetIds)
.PutExtra(EXTRA_WIDGET_TYPE, (int)WidgetType));
}
else
{
base.OnReceive(context, intent);
}
}
public override void OnAppWidgetOptionsChanged(Context context, AppWidgetManager appWidgetManager, int appWidgetId, Bundle newOptions)
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_RESIZEWIDGET)
.PutExtra(EXTRA_WIDGET_ID, appWidgetId)
.PutExtra(EXTRA_WIDGET_OPTIONS, newOptions)
.PutExtra(EXTRA_WIDGET_TYPE, (int)WidgetType));
}
protected void UpdateWidgets(Context context, int[] appWidgetIds)
{
ShowRefresh(context, appWidgetIds);
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REFRESHWIDGET)
.PutExtra(EXTRA_WIDGET_IDS, appWidgetIds)
.PutExtra(EXTRA_WIDGET_TYPE, (int)WidgetType));
}
public override void OnDisabled(Context context)
{
// Unregister tick receiver
if (Build.VERSION.SdkInt < BuildVersionCodes.JellyBeanMr1)
{
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_CANCELCLOCK));
}
base.OnDisabled(context);
}
public void OnSharedPreferenceChanged(ISharedPreferences sharedPreferences, string key)
{
if (String.IsNullOrWhiteSpace(key))
{
return;
}
Context context = Activity;
switch (key)
{
// Weather Provider changed
case KEY_API:
WeatherData.WeatherManager.GetInstance().UpdateAPI();
EnqueueIntent(new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDSETTINGSUPDATE));
goto case KEY_USECELSIUS;
// FollowGPS changed
case KEY_FOLLOWGPS:
EnqueueIntent(new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDSETTINGSUPDATE));
EnqueueIntent(new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDLOCATIONUPDATE));
goto case KEY_USECELSIUS;
// Settings unit changed
case KEY_USECELSIUS:
EnqueueIntent(new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
break;
// Refresh interval changed
case KEY_REFRESHINTERVAL:
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEALARM));
break;
default:
break;
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
if (messageEvent.Path.Equals(WearableHelper.StartActivityPath))
{
Intent startIntent = new Intent(this, typeof(LaunchActivity))
.SetFlags(ActivityFlags.ClearTop | ActivityFlags.NewTask | ActivityFlags.ClearTask);
StartActivity(startIntent);
}
else if (messageEvent.Path.Equals(WearableHelper.SettingsPath))
{
Task.Run(async() => await CreateSettingsDataRequest(true));
}
else if (messageEvent.Path.Equals(WearableHelper.LocationPath))
{
Task.Run(async() => await CreateLocationDataRequest(true));
}
else if (messageEvent.Path.Equals(WearableHelper.WeatherPath))
{
var data = messageEvent.GetData();
bool force = false;
if (data != null && data.Length > 0)
{
force = BitConverter.ToBoolean(data, 0);
}
if (!force)
{
Task.Run(async() => await CreateWeatherDataRequest(true));
}
else
{
// Refresh weather data
WeatherWidgetService.EnqueueWork(this, new Intent(this, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
}
}
else if (messageEvent.Path.Equals(WearableHelper.IsSetupPath))
{
SendSetupStatus(messageEvent.SourceNodeId);
}
}
public override void OnPause()
{
// Unregister listener
App.Preferences.UnregisterOnSharedPreferenceChangeListener(this);
App.Preferences.RegisterOnSharedPreferenceChangeListener(App.SharedPreferenceListener);
// Process queue
foreach (Intent intent in intentQueue)
{
if (intent.Component.ClassName.Equals(Java.Lang.Class.FromType(typeof(WeatherWidgetService)).Name))
{
WeatherWidgetService.EnqueueWork(Activity, intent);
}
else
{
this.Activity.StartService(intent);
}
}
base.OnPause();
}
public void OnWeatherLoaded(LocationData location, Weather weather)
{
AppCompatActivity?.RunOnUiThread(() =>
{
if (weather?.IsValid() == true)
{
wm.UpdateWeather(weather);
weatherView.UpdateView(weather);
SetView(weatherView);
if (Settings.HomeData.Equals(location))
{
// Update widgets if they haven't been already
if (TimeSpan.FromTicks(DateTime.Now.Ticks - Settings.UpdateTime.Ticks).TotalMinutes > Settings.RefreshInterval)
{
WeatherWidgetService.EnqueueWork(App.Context, new Intent(App.Context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
}
// Update ongoing notification if its not showing
if (Settings.OnGoingNotification && !Notifications.WeatherNotificationBuilder.IsShowing)
{
WeatherWidgetService.EnqueueWork(App.Context, new Intent(App.Context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REFRESHNOTIFICATION));
}
}
if (wm.SupportsAlerts && Settings.ShowAlerts &&
weather.weather_alerts != null && weather.weather_alerts.Count > 0)
{
// Alerts are posted to the user here. Set them as notified.
Task.Run(async() => await WeatherAlertHandler.SetasNotified(location, weather.weather_alerts));
}
}
refreshLayout.Refreshing = false;
});
}
public override void OnReceive(Context context, Intent intent)
{
if (Intent.ActionBootCompleted.Equals(intent?.Action))
{
// Reset weather update time
Settings.UpdateTime = DateTime.MinValue;
// Restart update alarm
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_STARTALARM));
}
else if (Intent.ActionLocaleChanged.Equals(intent?.Action))
{
UpdateWidgets(context, null);
}
else if (ACTION_SHOWREFRESH.Equals(intent?.Action))
{
// Update widgets
int[] appWidgetIds = intent.GetIntArrayExtra(EXTRA_WIDGET_IDS);
ShowRefresh(context, appWidgetIds);
}
else if (ACTION_REFRESHWIDGETS.Equals(intent?.Action))
{
// Update widgets
int[] appWidgetIds = intent.GetIntArrayExtra(EXTRA_WIDGET_IDS);
UpdateWidgets(context, appWidgetIds);
}
else if (AppWidgetManager.ActionAppwidgetUpdate.Equals(intent?.Action))
{
UpdateWidgets(context, null);
}
else
{
Logger.WriteLine(LoggerLevel.Info, "{0}: Unhandled action: {1}", TAG, intent?.Action);
base.OnReceive(context, intent);
}
}
private async Task PrepareWidget()
{
// Update Settings
if (refreshSpinner.SelectedItem is ComboBoxItem refreshItem)
{
if (int.TryParse(refreshItem.Value, out int refreshValue))
{
Settings.RefreshInterval = refreshValue;
}
}
// Get location data
if (locSpinner.SelectedItem is ComboBoxItem locationItem)
{
LocationData locData = null;
switch (locationItem.Value)
{
case "GPS":
Settings.FollowGPS = true;
if (gpsQuery_vm == null || mLocation == null)
{
await FetchGeoLocation();
}
else
{
locData = new LocationData(gpsQuery_vm, mLocation);
Settings.SaveLastGPSLocData(locData);
// Save locdata for widget
WidgetUtils.SaveLocationData(mAppWidgetId, locData);
WidgetUtils.AddWidgetId(locData.query, mAppWidgetId);
}
break;
default:
// Get location data
if (locSpinner.SelectedItem is ComboBoxItem item)
{
locData = Favorites.FirstOrDefault(loc => loc.query.Equals(item.Value));
if (locData == null && query_vm != null)
{
locData = new LocationData(query_vm);
if (!locData.IsValid())
{
SetResult(Result.Canceled, new Intent().PutExtra(AppWidgetManager.ExtraAppwidgetId, mAppWidgetId));
Finish();
return;
}
// Add location to favs
await Settings.AddLocation(locData);
}
else if (locData == null)
{
SetResult(Result.Canceled, new Intent().PutExtra(AppWidgetManager.ExtraAppwidgetId, mAppWidgetId));
Finish();
return;
}
// Save locdata for widget
WidgetUtils.SaveLocationData(mAppWidgetId, locData);
WidgetUtils.AddWidgetId(locData.query, mAppWidgetId);
}
break;
}
// Trigger widget service to update widget
WeatherWidgetService.EnqueueWork(this,
new Intent(this, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_REFRESHWIDGET)
.PutExtra(WeatherWidgetProvider.EXTRA_WIDGET_IDS, new int[] { mAppWidgetId }));
// Create return intent
Intent resultValue = new Intent();
resultValue.PutExtra(AppWidgetManager.ExtraAppwidgetId, mAppWidgetId);
SetResult(Result.Ok, resultValue);
Finish();
}
else
{
SetResult(Result.Canceled, new Intent().PutExtra(AppWidgetManager.ExtraAppwidgetId, mAppWidgetId));
Finish();
}
}
public void OnSharedPreferenceChanged(ISharedPreferences sharedPreferences, string key)
{
if (String.IsNullOrWhiteSpace(key))
{
return;
}
var context = Application.Context;
switch (key)
{
// Weather Provider changed
case KEY_API:
WeatherData.WeatherManager.GetInstance().UpdateAPI();
#if !__ANDROID_WEAR__
context.StartService(
new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDSETTINGSUPDATE));
#endif
goto case KEY_USECELSIUS;
// FollowGPS changed
case KEY_FOLLOWGPS:
#if !__ANDROID_WEAR__
context.StartService(
new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDSETTINGSUPDATE));
context.StartService(
new Intent(context, typeof(WearableDataListenerService))
.SetAction(WearableDataListenerService.ACTION_SENDLOCATIONUPDATE));
#endif
goto case KEY_USECELSIUS;
// Settings unit changed
case KEY_USECELSIUS:
#if __ANDROID_WEAR__
WeatherComplicationIntentService.EnqueueWork(context,
new Intent(context, typeof(WeatherComplicationIntentService))
.SetAction(WeatherComplicationIntentService.ACTION_UPDATECOMPLICATIONS)
.PutExtra(WeatherComplicationIntentService.EXTRA_FORCEUPDATE, true));
break;
#else
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
break;
// Refresh interval changed
case KEY_REFRESHINTERVAL:
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEALARM));
break;
#endif
#if __ANDROID_WEAR__
// Data sync setting changed
case KEY_DATASYNC:
// Reset UpdateTime value to force a refresh
UpdateTime = DateTime.MinValue;
break;
#endif
default:
break;
}
}
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);
}
public override void OnDisabled(Context context)
{
// Remove alarms/updates
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_CANCELALARM));
}
public override void OnEnabled(Context context)
{
// Schedule alarms/updates
WeatherWidgetService.EnqueueWork(context, new Intent(context, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_STARTALARM));
}
