/*
* 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 Test()
{
var tddHandler = new TDDHandler();
const String stringValue = "external string value";
const Int32 int32Value = 12345;
const String stringKeyName = "v2.string";
const String intKeyName = "v2.int";
var classPrefs = new NSUserDefaults();
classPrefs.SetString(stringValue, stringKeyName);
ExternalUserDefaultsClassSerializer.SetMyUserDefaults(classPrefs);
var fieldPrefs = new NSUserDefaults();
fieldPrefs.SetInt(int32Value, intKeyName);
ExternalUserDefaultsFieldSerializer.SetMyUserDefaults(fieldPrefs);
ExternalUserDefaultsSettings.IntValue = 0;
ExternalUserDefaultsSettings.StringValue = String.Empty;
ExternalUserDefaultsSettings.LoadSettings();
Assert.AreEqual(ExternalUserDefaultsSettings.IntValue, int32Value);
Assert.AreEqual(ExternalUserDefaultsSettings.StringValue, stringValue);
tddHandler.CheckErrors();
}
public static void setMaskType(int maskType)
{
NSUserDefaults prefs = NSUserDefaults.StandardUserDefaults;
prefs.SetInt(maskType, "maskType");
prefs.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 void SetToDefaults(string key, int value)
{
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetInt(value, key);
defaults.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();
};
}
partial void SearchProviderChanged(NSObject sender)
{
var userDefaults = new NSUserDefaults();
userDefaults.SetInt(CensusSearchProviderOutlet.SelectedIndex, "CensusProvider");
userDefaults.Synchronize();
}
private void SavePublicationDownladProgress(int bytesDownloaded)
{
NSUserDefaults userDefault = NSUserDefaults.StandardUserDefaults;
userDefault.SetInt(bytesDownloaded, BookTitle);
userDefault.Synchronize();
}
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
global::Xamarin.Forms.Forms.Init();
AnimationViewRenderer.Init();
LoadApplication(new App());
TinyPubSubLib.TinyPubSub.Subscribe <Core.Services.SummaryData>("SummaryData", (Core.Services.SummaryData data) =>
{
var shared = new NSUserDefaults(
"se.tinystuff.TinyShopping.shared",
NSUserDefaultsType.SuiteName);
shared.SetInt(data.TotalItems, "total");
shared.SetInt(data.DoneItems, "done");
// shared.Synchronize();
});
return(base.FinishedLaunching(app, options));
}
partial void UIButton12_TouchUpInside(UIButton sender)
{
//Store value on Userdefaults
storevalues.SetString(txtString.Text, "stringvalue");
storevalues.SetInt(Int32.Parse(txtInteger.Text), "integervalue");
//Get values form Userdefaults
lblString.Text = storevalues.StringForKey("stringvalue");
lblInteger.Text = storevalues.IntForKey("integervalue").ToString();
lblBoolean.Text = storevalues.BoolForKey("swithvalue").ToString();;
}
public void Set(string key, int?value)
{
if (!value.HasValue)
{
Clear(key);
}
else
{
Defaults.SetInt(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 override void ViewWillAppear(bool animated)
{
base.ViewWillAppear(animated);
tasks = AppDelegate.Database.GetItems();
// bind every time, to reflect deletion in the Detail view
TableView.Source = new RootTableSource(tasks.ToArray());
NSUserDefaults shared = new NSUserDefaults("group.co.conceptdev.TodoToday", NSUserDefaultsType.SuiteName);
shared.SetInt(tasks.Count, "TodoCount");
shared.Synchronize();
Console.WriteLine("Set NSUserDefaults TodoCount: " + tasks.Count);
}
public bool SetInt(string key, int 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.SetInt(val, key);
return(true);
}
catch (Exception e)
{
Logger.Error($"Error Setting Int 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;
}
}
void IncrementSignificantEventCount()
{
// get the app's version
string version = CurrentVersion;
// get the version number that we've been tracking
NSUserDefaults userDefaults = NSUserDefaults.StandardUserDefaults;
string trackingVersion = userDefaults.StringForKey(CURRENT_VERSION);
if (string.IsNullOrEmpty(trackingVersion))
{
trackingVersion = version;
userDefaults.SetString(version, CURRENT_VERSION);
}
if (settings.Debug)
{
Debug.WriteLine("APPIRATER Tracking version: {0}", trackingVersion);
}
if (trackingVersion == version)
{
// check if the first use date has been set. if not, set it.
double timeInterval = userDefaults.DoubleForKey(FIRST_USE_DATE);
if (timeInterval == 0)
{
timeInterval = DateTime.Now.ToOADate();
userDefaults.SetDouble(timeInterval, FIRST_USE_DATE);
}
// increment the significant event count
int sigEventCount = userDefaults.IntForKey(SIGNIFICANT_EVENT_COUNT);
sigEventCount++;
userDefaults.SetInt(sigEventCount, SIGNIFICANT_EVENT_COUNT);
if (settings.Debug)
{
Debug.WriteLine("APPIRATER Significant event count: {0}", sigEventCount);
}
}
else
{
Restart();
}
userDefaults.Synchronize();
}
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 DidReceiveNotificationRequest(UNNotificationRequest request, Action <UNNotificationContent> contentHandler)
{
ContentHandler = contentHandler;
BestAttemptContent = (UNMutableNotificationContent)request.Content.MutableCopy();
// Modify the notification content here...
var plist = new NSUserDefaults("group.com.libin.sharing", NSUserDefaultsType.SuiteName);
nint badgeCount = plist.IntForKey("BadgeCount");
badgeCount++;
var newAlertContent = new UNMutableNotificationContent
{
Body = BestAttemptContent.Body,
Title = BestAttemptContent.Title,
Sound = BestAttemptContent.Sound,
Badge = new NSNumber(badgeCount)
};
plist.SetInt(badgeCount, "BadgeCount");
ContentHandler(newAlertContent);
}
void UpdateDownloadProgress(int bytesDownloaded, long downloadSize)
{
float curProgress = (float)(bytesDownloaded / 100.0);
ProgressBar.DoubleValue = curProgress;
if ((bytesDownloaded - bytesPreDownloaded) > 2)
{
bytesPreDownloaded = bytesDownloaded;
NSUserDefaults userDefault = NSUserDefaults.StandardUserDefaults;
userDefault.SetInt(bytesDownloaded, BookInfo.Name);
userDefault.Synchronize();
}
if (bytesDownloaded == 100)
{
NSUserDefaults userDefault = NSUserDefaults.StandardUserDefaults;
userDefault.RemoveObject(BookInfo.Name);
userDefault.Synchronize();
}
}
/// <summary>
/// Sets the user session.
/// </summary>
/// <param name="userModel">User model.</param>
public static void SetUserSession(User userModel)
{
try
{
if (userModel != null)
{
_user = NSUserDefaults.StandardUserDefaults;
_user.SetInt(userModel.USER_ID, "USER_ID");
_user.SetString(userModel.USER_TYPE, "USER_TYPE");
_user.SetString(userModel.USER_NAME, "USER_NAME");
_user.SetString(userModel.SURNAME, "SURNAME");
_user.SetString(userModel.EMAIL, "EMAIL");
_user.SetString(userModel.MOBILE, "MOBILE");
_user.SetString(userModel.API_TOKEN, "API_TOKEN");
_user.SetString(userModel.HELPLINE, "HELPLINE");
_user.SetDouble(userModel.MIN_PRICE, "MIN_PRICE");
_user.Synchronize();
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public void SetInt(string key, int value)
{
_prefs.SetInt((nint)value, key);
_prefs.Synchronize();
}
async Task ReportScore()
{
string leaderboardIdentifier = null;
string gameTypeString = null;
GameTypePlayed gameType = GameTypePlayed.Invalid;
if (GameInfo.GameTime == GameTime.Fifteen)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "15secondseasymode";
gameType = GameTypePlayed.Easy15;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "15secondshardmode";
gameType = GameTypePlayed.Hard15;
}
}
else if (GameInfo.GameTime == GameTime.Thirty)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "30secondseasymode";
gameType = GameTypePlayed.Easy30;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "30secondshardmode";
gameType = GameTypePlayed.Hard30;
}
}
else if (GameInfo.GameTime == GameTime.FourtyFive)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "45secondseasymode";
gameType = GameTypePlayed.Easy45;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "45secondshardmode";
gameType = GameTypePlayed.Hard45;
}
}
if (gameTypeString != null)
{
leaderboardIdentifier = Prefix + gameTypeString;
}
if (leaderboardIdentifier != null)
{
GKScore score = new GKScore(leaderboardIdentifier)
{
Value = GameInfo.CurrentTaps,
Context = 0
};
var challenges = GameInfo.Challenge == null ? null : new [] { GameInfo.Challenge };
await GKScore.ReportScoresAsync(new [] { score }, challenges);
}
if (GKLocalPlayer.LocalPlayer.Authenticated)
{
if (GameInfo.GameMode == GameMode.Hard)
{
var playhard = new GKAchievement(PlayHardId, GKLocalPlayer.LocalPlayer.PlayerID)
{
PercentComplete = 100
};
await GKAchievement.ReportAchievementsAsync(new [] { playhard });
}
int playedGameTypesBitField;
using (NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults) {
playedGameTypesBitField = defaults.IntForKey("playedGameTypes") | (int)gameType;
defaults.SetInt(playedGameTypesBitField, "playedGameTypes");
defaults.Synchronize();
}
int numTypesPlayed = 0;
for (int i = 0; i < 6; i++)
{
if ((playedGameTypesBitField & 0x01) != 0)
{
numTypesPlayed++;
}
playedGameTypesBitField >>= 1;
}
GKAchievement playAllModesAchievement = new GKAchievement(PlayAllId)
{
PercentComplete = numTypesPlayed / 6.0 * 100.0
};
await GKAchievement.ReportAchievementsAsync(new [] { playAllModesAchievement });
await UpdateCurrentTapsLeaderboardAndTapAchievements();
}
}
/// <inheritdoc />
public void SetInt(string key, int value)
{
_standardDefaults.SetInt(value, key);
_standardDefaults.Synchronize();
}
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 static void PutStore(int storeid)
{
plist.SetInt(storeid, "storeid");
}
public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
{
int section = indexPath.Section;
int row = indexPath.Row;
switch (section)
{
case 1:
{
foreach (UITableViewCell c in tableView.VisibleCells)
{
c.Accessory = UITableViewCellAccessory.None;
}
tableView.DeselectRow(indexPath, true);
SettingsProfileTableViewCell cell = (SettingsProfileTableViewCell)tableView.CellAt(indexPath);
cell.Accessory = UITableViewCellAccessory.Checkmark;
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetInt(row, "selectedProfile");
defaults.Synchronize();
break;
}
case 4:
{
foreach (UITableViewCell c in tableView.VisibleCells)
{
c.Accessory = UITableViewCellAccessory.None;
}
tableView.DeselectRow(indexPath, true);
SettingsProfileTableViewCell cell = (SettingsProfileTableViewCell)tableView.CellAt(indexPath);
cell.Accessory = UITableViewCellAccessory.Checkmark;
NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;
defaults.SetInt(row, "selectedSaveFormat");
defaults.Synchronize();
break;
}
case 6:
{
AboutViewController vc = new AboutViewController();
vc.ModalPresentationStyle = UIModalPresentationStyle.FullScreen;
viewController.PresentViewController(vc, true, null);
break;
}
default:
{
tableView.DeselectRow(indexPath, false);
break;
}
}
}
static public void SaveSetting(string name, int val)
{
g_prefs.SetInt(val, name);
g_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();
});
}
}
});
}
protected void SetDateTime(string key, DateTime value)
{
var s = (int)(value - Epoch).TotalSeconds;
defs.SetInt(s, key);
}
public void Reset()
{
defs.SetInt(0, numPositiveKey);
defs.SetBool(false, shownKey);
}
