partial void ChangeSwitch(UISwitch sender)
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
nint tag = this.Tag;
bool on = this.SwitchCell.On;
if (tag == 100)
{
defaults.SetBool(on, "cropState");
}
else if (tag == 101)
{
defaults.SetBool(on, "cropMode");
}
else if (tag == 102)
{
defaults.SetBool(on, "borderDetector");
}
else if (tag == 103)
{
defaults.SetBool(on, "autoShot");
}
else if (tag == 104)
{
defaults.SetBool(on, "simulateMultipageFile");
}
else
{
return;
}
defaults.Synchronize();
}
/*
* Restarts tracking
*/
public void Restart()
{
string version = (NSString)NSBundle.MainBundle.InfoDictionary.ObjectForKey(new NSString("CFBundleVersion"));
NSUserDefaults userDefaults = NSUserDefaults.StandardUserDefaults;
userDefaults.SetString(version, CURRENT_VERSION);
userDefaults.SetDouble(DateTime.Now.ToOADate(), FIRST_USE_DATE);
userDefaults.SetInt(1, USE_COUNT);
userDefaults.SetInt(0, SIGNIFICANT_EVENT_COUNT);
userDefaults.SetBool(false, RATED_CURRENT_VERSION);
userDefaults.SetBool(false, DECLINED_TO_RATE);
userDefaults.SetDouble(0, REMINDER_REQUEST_DATE);
}
public void Save()
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetBool(enabled.Active, EnabledKey);
defaults.Synchronize();
}
static void ShowVoiceOverNotice()
{
var alert = new NSAlert();
alert.MessageText = GettextCatalog.GetString("Assistive Technology Detected");
alert.InformativeText = GettextCatalog.GetString("{0} has detected an assistive technology (such as VoiceOver) is running. Do you want to restart {0} and enable the accessibility features?", BrandingService.ApplicationName);
alert.AddButton(GettextCatalog.GetString("Restart and enable"));
alert.AddButton(GettextCatalog.GetString("No"));
var result = alert.RunModal();
switch (result)
{
case 1000:
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetBool(true, EnabledKey);
defaults.Synchronize();
IdeApp.Restart();
break;
default:
break;
}
}
public static void LockApplication()
{
NSUserDefaults settings = NSUserDefaults.StandardUserDefaults;
settings.SetBool(true, "IsLocked");
settings.Synchronize();
}
public void SetValue(string key, object anyValue)
{
Type valueType = anyValue.GetType();
if (valueType == typeof(string))
{
UserDefaults.SetString((string)anyValue, key);
}
else if (valueType == typeof(int))
{
UserDefaults.SetInt((int)anyValue, key);
}
else if (valueType == typeof(bool))
{
UserDefaults.SetBool((bool)anyValue, key);
}
else if (valueType == typeof(float))
{
UserDefaults.SetFloat((float)anyValue, key);
}
else if (valueType == typeof(double))
{
UserDefaults.SetDouble((double)anyValue, key);
}
else if (valueType == typeof(long))
{
UserDefaults.SetValueForKey(new NSNumber((long)anyValue), new NSString(key));
}
else
{
Log.Error(INCORRECT_VALUE_TYPE_ERROR);
}
UserDefaults.Synchronize();
}
public Task UpdateMultipleEntities(IEnumerable <Session> data)
{
return(Task.Run(() =>
{
var fileManager = new NSFileManager();
var appGroupContainer = fileManager.GetContainerUrl($"group.{AboutThisApp.PackageName}");
var appGroupContainerPath = appGroupContainer.Path;
var sessionsFilePath = Path.Combine(appGroupContainerPath, "sessions.json");
if (fileManager.FileExists(sessionsFilePath))
{
NSError error;
fileManager.Remove(sessionsFilePath, out error);
}
var attributes = new NSFileAttributes
{
Type = NSFileType.Regular
};
var json = JsonConvert.SerializeObject(data.Where(s => s.IsFavorite).ToList());
var fileData = NSData.FromString(json);
fileManager.CreateFile(sessionsFilePath, fileData, attributes);
var url = NSUrl.FromFilename(sessionsFilePath);
url.SetResource(NSUrl.IsExcludedFromBackupKey, new NSNumber(true));
var settings = new NSUserDefaults($"group.{AboutThisApp.PackageName}", NSUserDefaultsType.SuiteName);
settings.SetBool(true, "FavoritesInitialized");
settings.Synchronize();
UpdateWidget();
}));
}
public static void setIsUseKeyAction(bool isUseKeyAction)
{
NSUserDefaults prefs = NSUserDefaults.StandardUserDefaults;
prefs.SetBool(isUseKeyAction, "isUseKeyAction");
prefs.Synchronize();
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
LePreferencias();
txtNome.ShouldReturn += (textField) => {
txtNome.ResignFirstResponder();
return(true);
};
btnLer.TouchUpInside += (object sender, EventArgs e) => {
LePreferencias();
};
btnGravar.TouchUpInside += (object sender, EventArgs e) => {
prefs.SetBool(boolSwitch.On, "habilitado");
prefs.SetString(txtNome.Text, "user");
prefs.SetFloat(floatSlider.Value, "slider");
prefs.SetInt(Convert.ToInt32(lblInt.Text), "int");
prefs.SetDouble(dtPicker.Date.SecondsSinceReferenceDate, "data");
};
intStepper.ValueChanged += (object sender, EventArgs e) => {
lblInt.Text = intStepper.Value.ToString();
};
}
public void SetTimerUserDefaults()
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetBool(Running, "running");
defaults.SetString(StartDate.Ticks.ToString(), "ticks");
defaults.Synchronize();
}
private void SignInOnCompletion(User user, NSError error)
{
if (error != null)
{
AuthErrorCode errorCode;
if (IntPtr.Size == 8) // 64 bits devices
{
errorCode = (AuthErrorCode)((long)error.Code);
}
else // 32 bits devices
{
errorCode = (AuthErrorCode)((int)error.Code);
}
// Posible error codes that SignIn method with email and password could throw
// Visit https://firebase.google.com/docs/auth/ios/errors for more information
switch (errorCode)
{
case AuthErrorCode.OperationNotAllowed:
case AuthErrorCode.InvalidEmail:
case AuthErrorCode.UserDisabled:
case AuthErrorCode.WrongPassword:
default:
if (errorCode == AuthErrorCode.KeychainError)
{
if (OnLoginSuccess != null)
{
// Get Shared User Defaults
_plist.SetString(_email, "email");
_plist.SetBool(true, "isAuthenticated");
OnLoginSuccess(_sender, new EventArgs());
}
break;
}
new UIAlertView("Login Error", "Bad user name or password" + errorCode, null, "OK", null).Show();
//AppDelegate.ShowMessage("Could not login!", error.LocalizedDescription, NavigationController);
_plist.SetBool(true, "isAuthenticated");
break;
}
return;
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
// Perform any additional setup after loading the view, typically from a nib.
switchOnOff.On = false;
switchOnOff.ValueChanged += (sender, e) =>
{
if (switchOnOff.On == true)
{
//Store value on Userdefaults
storevalues.SetBool(switchOnOff.On = true, "swithvalue");
}
else
{
//Store value on Userdefaults
storevalues.SetBool(switchOnOff.On = false, "swithvalue");
}
};
}
public void Set(string key, bool?value)
{
if (!value.HasValue)
{
Clear(key);
}
else
{
Defaults.SetBool(value.Value, key);
Defaults.Synchronize();
}
}
public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
if (!defaults.BoolForKey("isItFirstRun"))
{
defaults.SetBool(true, "cropState");
defaults.SetBool(true, "borderDetector");
defaults.SetBool(true, "autoShot");
defaults.SetBool(true, "torchState");
defaults.SetInt(1, "selectedProfile");
defaults.SetString("0.7", "DelayValue");
defaults.SetInt(0, "selectedSaveFormat");
defaults.SetBool(true, "isItFirstRun");
defaults.Synchronize();
}
this.Window.RootViewController = this.ViewController;
this.Window.MakeKeyAndVisible();
return(true);
}
public void RunHandlerOnFirstLaunch(Action firstLaunchHandler)
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.RegisterDefaults(new NSMutableDictionary {
{ (NSString)FirstLaunchUserDefaultsKey, NSObject.FromObject(true) },
{ (NSString)StorageOptionUserDefaultsKey, NSObject.FromObject(StorageType.NotSet) }
});
if (defaults.BoolForKey(FirstLaunchUserDefaultsKey))
{
defaults.SetBool(false, FirstLaunchUserDefaultsKey);
firstLaunchHandler();
}
}
/*
* Tells Appirater to open the App Store page where the user can specify a
* rating for the app. Also records the fact that this has happened, so the
* user won't be prompted again to rate the app.
*
* The only case where you should call this directly is if your app has an
* explicit "Rate this app" command somewhere. In all other cases, don't worry
* about calling this -- instead, just call the other functions listed above,
* and let Appirater handle the bookkeeping of deciding when to ask the user
* whether to rate the app.
*/
public void RateApp()
{
if (Runtime.Arch == Arch.SIMULATOR)
{
Debug.WriteLine("APPIRATER NOTE: iTunes App Store is not supported on the iOS simulator. Unable to open App Store page.");
}
else
{
NSUserDefaults userDefaults = NSUserDefaults.StandardUserDefaults;
string reviewURL = string.Format(TEMPLATE_REVIEW_URL, settings.AppId);
userDefaults.SetBool(true, RATED_CURRENT_VERSION);
userDefaults.Synchronize();
UIApplication.SharedApplication.OpenUrl(NSUrl.FromString(reviewURL));
}
}
public bool SetBool(string key, bool val)
{
try
{
// Apple now recommends you *don't* call Synchronize as it will periodically happen
// https://docs.microsoft.com/en-us/xamarin/ios/app-fundamentals/user-defaults
_defaults.SetBool(val, key);
return(true);
}
catch (Exception e)
{
Logger.Error($"Error Setting Bool UserSetting {key} - {e.Message}", e);
}
return(false);
}
private bool EditPreferences(NSUserDefaults defaults, UserModel user)
{
try
{
defaults.SetString(user.Email, "user_mail");
defaults.SetBool(user.IsLogged, "is_logged");
defaults.SetString(user.PhotoUrl, "user_photo_url");
defaults.SetInt(user.UserId, "user_user_id");
defaults.SetString(user.Username, "user_username");
return(true);
}
catch (Exception e)
{
Debug.WriteLine("AUTHENTICATOR MANAGER", "Catched exception.");
throw e;
}
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
UpdateSessionsSource();
TabBarController.Title = StringResources.sessions_ui_title;
SessionsInstructions.Text = StringResources.sessions_ui_header_instructions;
SessionsInstructionsBody.Text = StringResources.sessions_ui_body_instructions;
NSUserDefaults prefs = NSUserDefaults.StandardUserDefaults;
if (prefs.BoolForKey("SESSION_RECORDED"))
{
prefs.SetBool(false, "SESSION_RECORDED");
// Get epoch time
TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1);
int secondsSinceEpoch = (int)t.TotalSeconds;
Analytics.SetUserProperty(
"lastUploadAdded",
secondsSinceEpoch.ToString());
var currentConnections = CrossConnectivity.Current.ConnectionTypes;
if (!currentConnections.Contains(Plugin.Connectivity.Abstractions.ConnectionType.WiFi))
{
var alertController = UIAlertController.Create(StringResources.sessions_ui_wifiwarning_title,
StringResources.sessions_ui_wifiwarning_message,
UIAlertControllerStyle.Alert);
alertController.AddAction(UIAlertAction.Create(StringResources.sessions_ui_wifiwarning_cancel,
UIAlertActionStyle.Cancel, (obj) => { }));
alertController.AddAction(UIAlertAction.Create(StringResources.sessions_ui_wifiwarning_confirm,
UIAlertActionStyle.Default, (obj) =>
{
UploadIfNot(0, true);
}));
PresentViewController(alertController, true, null);
}
else
{
UploadIfNot(0, true);
}
}
}
public void Set(string key, object value)
{
if (value == null)
{
Defaults.RemoveObject(key);
}
else if (value is int)
{
Defaults.SetInt((int)value, key);
}
else if (value is bool)
{
Defaults.SetBool((bool)value, key);
}
else if (value is string)
{
Defaults.SetString((string)value, key);
}
Defaults.Synchronize();
}
public override void Clicked(UIAlertView alertview, int buttonIndex)
{
NSUserDefaults userDefaults = NSUserDefaults.StandardUserDefaults;
switch (buttonIndex)
{
case 0:
// they don't want to rate it
userDefaults.SetBool(true, DECLINED_TO_RATE);
userDefaults.Synchronize();
break;
case 1:
// they want to rate it
owner.RateApp();
break;
case 2:
// remind them later
userDefaults.SetDouble(DateTime.Now.ToOADate(), REMINDER_REQUEST_DATE);
userDefaults.Synchronize();
break;
}
}
public static void LoadDefaults(this NSUserDefaults defaults)
{
if (!defaults.BoolForKey("__DefaultsLoaded"))
{
using (NSDictionary settings = new NSDictionary(Paths.SettingsPlist))
{
using (NSArray prefs = (NSArray)settings.ObjectForKey(new NSString("PreferenceSpecifiers")))
{
using (NSString keyString = new NSString("Key"),
defaultValueString = new NSString("DefaultValue"))
{
for (uint i = 0; i < prefs.Count; i++)
{
using (NSDictionary item = new NSDictionary(prefs.ValueAt(i)))
{
using (NSObject key = item[keyString])
{
NSObject defaultValue = item[defaultValueString];
if (defaultValue != null)
{
using (defaultValue)
{
defaults[key.ToString()] = defaultValue;
}
}
}
}
}
}
}
}
defaults.SetBool(true, "__DefaultsLoaded");
defaults.Synchronize();
}
}
static public void SaveSetting(string name, bool val)
{
g_prefs.SetBool(val, name);
g_prefs.Synchronize();
}
public void SetBool(string key, bool value)
{
_prefs.SetBool(value, key);
_prefs.Synchronize();
}
public void DoWorkInBackground()
{
ThreadPool.QueueUserWorkItem(delegate {
using (NSAutoreleasePool autorelease = new NSAutoreleasePool())
{
Util.Log("Apirator launched");
bool forceShowDialog = false;
#if DEBUG
//forceShowDialog = true;
#endif
bool shouldShowDialog = false;
string currentVersion = NSBundle.MainBundle.ObjectForInfoDictionary("CFBundleVersion").ToString();
using (NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults)
{
string trackingVersion = defaults.StringForKey(CONFIG_CURRENTVERSION);
if (trackingVersion == null)
{
trackingVersion = currentVersion;
defaults.SetString(trackingVersion, CONFIG_CURRENTVERSION);
}
Util.Log("Tracking version: " + trackingVersion);
if (trackingVersion == currentVersion)
{
int launchCount = defaults.IntForKey(CONFIG_LAUNCHCOUNT);
launchCount++;
defaults.SetInt(launchCount, CONFIG_LAUNCHCOUNT);
Util.Log("Launch count is: " + launchCount);
bool declinedToRate = defaults.BoolForKey(CONFIG_DECLINEDTORATE);
bool hasRated = defaults.BoolForKey(CONFIG_RATEDCURRENTVERSION);
if (launchCount > LAUNCHES_UNTIL_PROMPT &&
!declinedToRate &&
!hasRated)
{
if (IsConnectedToNetwork())
{
shouldShowDialog = true;
}
}
defaults.Synchronize();
}
else
{
Util.Log("Setting defatuls");
defaults.SetString(currentVersion, CONFIG_CURRENTVERSION);
defaults.SetInt(1, CONFIG_LAUNCHCOUNT);
defaults.SetBool(false, CONFIG_RATEDCURRENTVERSION);
defaults.SetBool(false, CONFIG_DECLINEDTORATE);
defaults.Synchronize();
}
}
if (shouldShowDialog || forceShowDialog)
{
Util.Log("Apirator: Showing Dialog");
UIApplication.SharedApplication.InvokeOnMainThread(delegate {
alertView = new UIAlertView(string.Format(MESSAGE_TITLE, APP_NAME),
string.Format(MESSAGE, APP_NAME),
null,
CANCEL_BUTTON,
string.Format(RATE_BUTTON, APP_NAME),
LATER_BUTTON);
alertView.Clicked += delegate(object sender, UIButtonEventArgs e) {
using (NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults)
{
switch (e.ButtonIndex)
{
case 0:
defaults.SetBool(true, CONFIG_DECLINEDTORATE);
defaults.Synchronize();
Util.Log("declined to rate. Boo");
break;
case 1:
Util.Log("rating it! yay!");
string reviewUrl = string.Format(TemplateReviewUrl, APP_ID);
Util.Log(reviewUrl);
UIApplication.SharedApplication.OpenUrl(new NSUrl(reviewUrl));
defaults.SetBool(true, CONFIG_RATEDCURRENTVERSION);
defaults.Synchronize();
break;
case 2:
Util.Log("doing it later");
defaults.SetInt(5, CONFIG_LAUNCHCOUNT);
defaults.Synchronize();
int launchCount = defaults.IntForKey(CONFIG_LAUNCHCOUNT);
Util.Log("Launch count is: " + launchCount);
break;
}
}
};
alertView.Canceled += delegate(object sender, EventArgs e) {
};
alertView.Show();
});
}
}
});
}
public void SetBool(bool isChecked, string BoolToSet)
{
userSettings.SetBool(isChecked, BoolToSet);
userSettings = NSUserDefaults.StandardUserDefaults;
}
private void SetItem(string key, object value)
{
if (value == null)
{
if (IsRoaming)
{
_store.Remove(key);
}
else
{
_defaults.RemoveObject(key);
}
}
else
{
TypeCode code = Type.GetTypeCode(value.GetType());
switch (code)
{
case TypeCode.String:
if (IsRoaming)
{
_store.SetString(key, value.ToString());
}
else
{
_defaults.SetString(value.ToString(), key);
}
break;
case TypeCode.Int32:
if (IsRoaming)
{
_store.SetLong(key, (long)value);
}
else
{
_defaults.SetInt((int)value, key);
}
break;
case TypeCode.Double:
if (IsRoaming)
{
_store.SetDouble(key, (double)value);
}
else
{
_defaults.SetDouble((double)value, key);
}
break;
case TypeCode.Single:
if (IsRoaming)
{
_store.SetDouble(key, (double)value);
}
else
{
_defaults.SetFloat((float)value, key);
}
break;
case TypeCode.Boolean:
if (IsRoaming)
{
_store.SetBool(key, (bool)value);
}
else
{
_defaults.SetBool((bool)value, key);
}
break;
default:
if (IsRoaming)
{
_store.SetValueForKey(IOSTypeConverter.ConvertToNSObject(value), new NSString(key));
}
else
{
_defaults.SetValueForKey(IOSTypeConverter.ConvertToNSObject(value), new NSString(key));
}
break;
}
}
}
public void SetNeedsSync(bool value)
{
userDefaults.SetBool(value, NeedsSyncKey);
userDefaults.Synchronize();
}
public static void SetStartAtLogon(bool value)
{
defaults.Synchronize();
defaults.SetBool(value, kStartAtLogon);
}
public void Reset()
{
defs.SetInt(0, numPositiveKey);
defs.SetBool(false, shownKey);
}
