public override void ViewDidLoad()
        {
            base.ViewDidLoad ();
            Title = "WatchTodo";
            // Perform any additional setup after loading the view, typically from a nib.

            NSUserDefaults shared = new NSUserDefaults(
                "group.co.conceptdev.WatchTodo", NSUserDefaultsType.SuiteName);
            var isEnabled = shared.BoolForKey ("enabled_preference");
            var name = shared.StringForKey ("name_preference");
            Console.WriteLine ("Enabled: " + isEnabled);
            Console.WriteLine ("Name: " + name);
            //Title = name; // for testing
        }
Example #2
0
        static iCloudPrefs()
        {
            if (CoreXT.IsDevice) {

                // get id from user defaults
                _userDefaults = NSUserDefaults.StandardUserDefaults();
                iCloudID = _userDefaults.Object(ID_KEY) as string;

                store = NSUbiquitousKeyValueStore.DefaultStore();
                store.DidChangeExternally += _OnStoreChanged;

                NSFileManager.DefaultManager().UbiquityIdentityDidChange += _Init;
                CoreXT.ApplicationResumed += _Init;

                _Init();
            }
        }
        public override void ViewWillAppear(bool animated)
        {
            base.ViewWillAppear (animated);

            NSUserDefaults shared = new NSUserDefaults("group.com.conceptdevelopment.TodoToday", NSUserDefaultsType.SuiteName);
            var count = shared.IntForKey ("TodoCount");
            Console.WriteLine ("Read NSUserDefaults TodoCount: " + count);

            if (count == 0) {
                todoLabel.Text = "nothing to do";
            } else if (count == 1) {
                todoLabel.Text = "one thing to do";
            } else  {
                todoLabel.Text = String.Format("{0} things to do", count);
            }

            //			textToSpeak = todoLabel.Text;
        }
Example #4
0
        public SettingsImpl(string nameSpace) {
            this.KeysNotToClear = new List<string> {
                "WebKitKerningAndLigaturesEnabledByDefault",
                "AppleLanguages",
                "monodevelop-port",
                "AppleITunesStoreItemKinds",
                "AppleLocale",
                "connection-mode",
                "AppleKeyboards",
                "NSLanguages",
                "UIDisableLegacyTextView",
                "NSInterfaceStyle"
            };

            if (nameSpace == null) {
                this.prefs = NSUserDefaults.StandardUserDefaults;
                this.IsRoamingProfile = false;
            }
            else {
                this.prefs = new NSUserDefaults(nameSpace, NSUserDefaultsType.SuiteName);
                this.IsRoamingProfile = true;
            }
        }
Example #5
0
            public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
            {
                SettingsTableViewCell        cell;
                SettingsProfileTableViewCell cell2;
                TextTableViewCell            cell3;

                int section = indexPath.Section;
                int row     = indexPath.Row;

                if (section == 0)
                {
                    if (row == 0)
                    {
                        cell     = (SettingsTableViewCell)tableView.DequeueReusableCell(CELL_ID, indexPath);
                        cell.Tag = 100;
                        cell.UpdateLabelText();

                        return(cell);
                    }
                    else if (row == 1)
                    {
                        cell     = (SettingsTableViewCell)tableView.DequeueReusableCell(CELL_ID, indexPath);
                        cell.Tag = 101;
                        cell.UpdateLabelText();

                        return(cell);
                    }
                }
                else if (section == 1)
                {
                    cell2 = (SettingsProfileTableViewCell)tableView.DequeueReusableCell(PROFILE_CELL_ID, indexPath);

                    NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;

                    nint row_ = defaults.IntForKey("selectedProfile");

                    if (row_ == row)
                    {
                        cell2.Accessory = UITableViewCellAccessory.Checkmark;
                    }
                    else
                    {
                        cell2.Accessory = UITableViewCellAccessory.None;
                    }

                    switch (row)
                    {
                    case 0:
                        cell2.Configure("profile_button_original", "Original");
                        break;

                    case 1:
                        cell2.Configure("profile_button_bw", "Black & White");
                        break;

                    case 2:
                        cell2.Configure("profile_button_gray", "Gray");
                        break;

                    case 3:
                        cell2.Configure("profile_button_color", "Color");
                        break;
                    }

                    return(cell2);
                }
                else if (section == 2)
                {
                    cell           = (SettingsTableViewCell)tableView.DequeueReusableCell(CELL_ID, indexPath);
                    cell.Accessory = UITableViewCellAccessory.None;

                    if (row == 0)
                    {
                        cell.Tag = 102;
                    }
                    else
                    {
                        cell.Tag = 103;
                    }

                    cell.UpdateLabelText();

                    return(cell);
                }
                else if (section == 3)
                {
                    cell3           = (TextTableViewCell)tableView.DequeueReusableCell(TEXT_PROFILE_CELL_ID, indexPath);
                    cell3.Accessory = UITableViewCellAccessory.None;

                    if (row == 0)
                    {
                        cell3.Tag = 104;
                    }

                    cell3.UpdateLabelText();

                    return(cell3);
                }
                else if (section == 4)
                {
                    cell2 = (SettingsProfileTableViewCell)tableView.DequeueReusableCell(PROFILE_CELL_ID, indexPath);

                    NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults;

                    nint row_ = defaults.IntForKey("selectedSaveFormat");

                    cell2.Accessory =
                        row_ == row ?
                        UITableViewCellAccessory.Checkmark :
                        UITableViewCellAccessory.None
                    ;

                    switch (row)
                    {
                    case 0:
                        cell2.Configure("save_format_button_pdf", "PDF");
                        break;

                    case 1:
                    {
                        cell2.Configure("save_format_button_pdf_from_png", "PDF from PNG");
                        break;
                    }

                    case 2:
                    {
                        cell2.Configure("save_format_button_tiff", "TIFF G4");
                        break;
                    }

                    case 3:
                    {
                        cell2.Configure("save_format_button_png", "PNG");
                        break;
                    }

                    case 4:
                    {
                        cell2.Configure("save_format_button_jpg", "JPG");
                        break;
                    }
                    }

                    return(cell2);
                }
                else if (section == 5)
                {
                    cell           = (SettingsTableViewCell)tableView.DequeueReusableCell(CELL_ID, indexPath);
                    cell.Accessory = UITableViewCellAccessory.None;
                    cell.Tag       = 104;

                    cell.UpdateLabelText();

                    return(cell);
                }
                else if (section == 6)
                {
                    cell2           = (SettingsProfileTableViewCell)tableView.DequeueReusableCell(PROFILE_CELL_ID, indexPath);
                    cell2.Accessory = UITableViewCellAccessory.None;
                    cell2.Configure("", "About product");

                    return(cell2);
                }

                return(null);
            }
Example #6
0
 public static T GetSerializedObject <T> (this NSUserDefaults instance, string defaultName)
 {
     return(SerializerHelper.DeserializeObject <T> (instance.StringForKey(defaultName)));
 }
Example #7
0
        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 = (int)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();
            }
        }
Example #8
0
 public TouchStoredSettingsBase()
 {
     _preferences = NSUserDefaults.StandardUserDefaults;
 }
Example #9
0
 public PreferencesService()
 {
     _standardDefaults = NSUserDefaults.StandardUserDefaults;
 }
        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();
            _appController.ShowSelected += toggleShowSelected;
            userDefs = NSUserDefaults.StandardUserDefaults;

            UIApplication.Notifications.ObserveDidEnterBackground ((sender, args) => {
                var ser = JsonSerializer.SerializeToString (_appController.Eigenschappen);
                if (IsProfileNull) {
                    userDefs.SetString (ser, "eigenschappen");
                    userDefs.Synchronize ();
                } else {
                    _appController.AddOrUpdateEigenschappenSer (currProfiel.name, ser);
                }
            });
        }
		void SetElementValueFromDefaults(EntryElement e, NSUserDefaults defs, string key, string defaultVal)
		{
			string value = defs.StringForKey (key);
			if (value == null)
				e.Value = defaultVal;
			else
				e.Value = value;
		}
Example #12
0
 public static IDictionary <string, string> AsDictionary(this NSUserDefaults defaults)
 {
     return(defaults
            .ToDictionary()
            .ToDictionary(x => x.Key.ToString(), x => x.Value.ToString()));
 }
        public override void WillActivate()
        {
            // This method is called when the watch view controller is about to be visible to the user.
            Console.WriteLine ("{0} will activate", this);

            NSUserDefaults shared = new NSUserDefaults ();
            var isEnabled = shared.BoolForKey ("enabled_preference");
            var name = shared.StringForKey ("name_preference");
            Console.WriteLine ("Enabled: " + isEnabled);
            Console.WriteLine ("Name: " + name);

            // reload each view
            data = Database.GetItems ().ToList();

            // HACK: the recommendation is to use Insert and Remove rows
            // becaues if you reload the entire table, all the data is
            // re-sent from the extension to the watch
            TodoTable.SetNumberOfRows ((nint)data.Count, "todoRow");
            for (var i = 0; i < data.Count; i++) {
                var elementRow = (TodoRowController)TodoTable.GetRowController (i);
                elementRow.Set(data [i].Name, data [i].Done);
            }
        }
        public void RespondToChangeEvent(object sender, CheckPointDataChangedEventArgs args)
        {
            ToastNotificationType type;

            switch (args.ActionOccurred) {
            case ActionType.Deleted:
                type = ToastNotificationType.Error;
                break;
            case ActionType.Written:
                type = ToastNotificationType.Warning;
                break;
            default:
                type = ToastNotificationType.Info;
                break;
            }

            var ud = new NSUserDefaults(AppGroupPathProvider.SuiteName, NSUserDefaultsType.SuiteName);
            ud.SetValueForKey(DateTime.Now.ToNSDate(), new NSString("MRU"));
            ud.Synchronize();

            notify (args.Result.ToString(), string.Format ("{0} {1}", args.Entity, args.ActionOccurred.ToString ()), type);
            if (args.ConditionallyRefreshData)
                this.ConditionallyRefreshData (true);
            if (args.RespondToModelChanges&!args.ConditionallyRefreshData)
                this.RespondToModelChanges ();
        }
Example #15
0
 public Settings(string defaultsName)
 {
     _defaults = string.IsNullOrWhiteSpace(defaultsName) ? NSUserDefaults.StandardUserDefaults
         : new NSUserDefaults(defaultsName, NSUserDefaultsType.SuiteName);
 }
Example #16
0
 public AuthenticatorService()
 {
     this.userDefaults = NSUserDefaults.StandardUserDefaults;
     this.currentUser  = this.ReadUserFromPreferences(this.userDefaults);
 }
Example #17
0
 public override void ViewDidLoad()
 {
     base.ViewDidLoad();
     userDefs = NSUserDefaults.StandardUserDefaults;
 }
Example #18
0
 /// <summary>
 /// Dispose the local database.
 /// </summary>
 public override void Dispose()
 {
     _userDefaults = null;
 }
Example #19
0
        protected override IPreferenceStore CreatePreferenceStore()
        {
            const string preferencesVersionKey = "preferencesVersion";
            const string inspectorBundleId     = "com.xamarin.Inspector";

            var preferenceStore = new NSUserDefaultsPreferenceStore(synchronizeOnSet: true);

            // Check for, and if necessary, perform a one-time preferences migration from
            // com.xamarin.Inspector to com.xamarin.Workbooks, allowing the two client
            // applications to more fully split (they no longer share CFBundleIdentifier)
            if (ClientInfo.Flavor == ClientFlavor.Inspector ||
                preferenceStore.GetInt64(preferencesVersionKey) >= 2)
            {
                return(preferenceStore);
            }

            var migratedPrefs = 0;

            using (var inspectorDefaults = new NSUserDefaults()) {
                inspectorDefaults.AddSuite(inspectorBundleId);

                foreach (var item in inspectorDefaults.ToDictionary())
                {
                    if (item.Key is NSString nsKey && item.Value != null)
                    {
                        var key = nsKey.ToString();
                        switch (key)
                        {
                        // preserve some Cocoa/WebKit preferences
                        case "WebKitDeveloperExtras":
                        case "NSNavLastRootDirectory":
                        case "NSNavRecentPlaces":
                            break;

                        default:
                            // preserve all nav panel (open/save) prefs
                            if (key.StartsWith("NSNavPanel", StringComparison.Ordinal))
                            {
                                break;
                            }

                            // lastly, preserve our own explicit preferences
                            if (key.StartsWith(inspectorBundleId + ".", StringComparison.Ordinal))
                            {
                                key = preferenceStore.BundleId + key.Substring(inspectorBundleId.Length);
                                break;
                            }

                            // there are tons of "junk" preferences/state stored by various
                            // controls (e.g. frame dimensions) that I'd rather just discard
                            continue;
                        }

                        preferenceStore.UserDefaults.SetValueForKey(item.Value, new NSString(key));
                        migratedPrefs++;
                    }
                }

                preferenceStore.Set(preferencesVersionKey, 2);
                preferenceStore.UserDefaults.Synchronize();

                Log.Info(TAG, $"Migrated {migratedPrefs} preferences from " +
                         $"{inspectorBundleId} to {preferenceStore.BundleId}");
            }

            return(preferenceStore);
        }
		public DocumentAppSettings (NSUserDefaults defaults)
		{
			if (defaults == null)
				throw new ArgumentNullException ("defaults");
			defs = defaults;
		}
 public IOSSettingsStorage()
     : base()
 {
     this.userDefaults = new NSUserDefaults();
 }
Example #22
0
 public override void ClearSettings()
 {
     NSUserDefaults.ResetStandardUserDefaults();
     NSUserDefaults.StandardUserDefaults.Synchronize();
 }
 public EncryptedUserDefaults(string name, NSUserDefaults defaults) : this(name, defaults, new TinkAead(name))
 {
 }
 public UserPreferences()
 {
     _plist = NSUserDefaults.StandardUserDefaults;
 }
 public EncryptedUserDefaults(string name, NSUserDefaults defaults, IAead provider)
 {
     _name        = name;
     UserDefaults = defaults;
     _provider    = provider;
 }
Example #26
0
 public TouchStorage()
 {
     _prefs = NSUserDefaults.StandardUserDefaults;
 }
Example #27
0
        public static int getMaskType()
        {
            NSUserDefaults prefs = NSUserDefaults.StandardUserDefaults;

            return((int)prefs.IntForKey("maskType"));
        }
Example #28
0
        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();
                        });
                    }
                }
            });
        }
Example #29
0
        public static bool getIsUseKeyAction()
        {
            NSUserDefaults prefs = NSUserDefaults.StandardUserDefaults;

            return(prefs.BoolForKey("isUseKeyAction"));
        }
Example #30
0
 public TouchStorage()
 {
     _prefs = NSUserDefaults.StandardUserDefaults;
 }
Example #31
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
            // Perform any additional setup after loading the view, typically from a nib.

            NSUserDefaults plist  = NSUserDefaults.StandardUserDefaults;
            string         userid = plist.StringForKey("userid");

            Console.WriteLine("user id: " + userid);
            if (userid != null && !userid.Equals(""))
            {
                UserIdTextField.Text = userid;
                LoginButton.SetTitle("Logout", UIControlState.Normal);
            }

            LoginButton.TouchUpInside += (object sender, EventArgs e) =>
            {
                if (userid == null || userid.Equals(""))
                {
                    // Login
                    string newUserId = UserIdTextField.Text;
                    if (newUserId != null && !newUserId.Equals(""))
                    {
                        plist.SetString(newUserId, "userid");
                        plist.Synchronize();
                        userid = newUserId;
                        LoginButton.SetTitle("Logout", UIControlState.Normal);

                        WebEngage.SharedInstance().User.Login(newUserId);
                    }
                }
                else
                {
                    // Logout
                    plist.SetString("", "userid");
                    plist.Synchronize();
                    userid = "";
                    UserIdTextField.Text = "";
                    LoginButton.SetTitle("Login", UIControlState.Normal);

                    WebEngage.SharedInstance().User.Logout();
                }
            };

            TrackButton.TouchUpInside += (object sender, EventArgs e) =>
            {
                // Track
                string eventName = EventTextField.Text;
                if (eventName != null && !eventName.Equals(""))
                {
                    WebEngage.SharedInstance().Analytics.TrackEventWithName(eventName);
                }
            };

            SetButton.TouchUpInside += (object sender, EventArgs e) =>
            {
                // Set screen
                string screen = ScreenTextField.Text;
                if (screen != null && !screen.Equals(""))
                {
                    WebEngage.SharedInstance().Analytics.NavigatingToScreenWithName(screen);
                }
            };

            TestButton.TouchUpInside += (object sender, EventArgs e) =>
            {
                // For testing
            };
        }
Example #32
0
        /// <summary>
        /// Synchronizes the with data dictionary.
        /// </summary>
        /// <param name="dataDict">
        /// The data dictionary.
        /// </param>
        /// <returns>
        /// The <see cref="int"/>.
        /// </returns>
        public int SyncWithDataDictionary(Dictionary <string, object> dataDict)
        {
            var fullSync     = false;
            var dataModelDef = dataDict.ValueOrDefault("dataModel") as JObject;

            if (dataModelDef != null)
            {
                // DDLogCRequest("Import DATAMODEL");
                this.Logger.LogDebug("Import DATAMODEL", LogFlag.LogRequests);
                var dataModelSync = new UPSyncDataModel(this.DataStore);

                dataModelSync.SyncWithDataModelDefinition(dataModelDef.ToObject <Dictionary <string, object> >());

                fullSync = true;
            }

            var            catalogDef  = dataDict.ValueOrDefault("fixedCatalogs") as JArray;
            UPSyncCatalogs catalogSync = null;

            if (catalogDef != null)
            {
                // DDLogCRequest("Import FIXED CATALOGS");
                this.Logger.LogDebug("Import FIXED CATALOGS", LogFlag.LogRequests);
                catalogSync = new UPSyncCatalogs(this.DataStore);
                catalogSync.SyncFixedCatalogs(catalogDef.ToObject <List <object> >());
            }

            catalogDef = dataDict.ValueOrDefault("variableCatalogs") as JArray;
            if (catalogDef != null)
            {
                // DDLogCRequest("Import VARIABLE CATALOGS");
                this.Logger.LogDebug("Import VARIABLE CATALOGS", LogFlag.LogRequests);
                if (catalogSync == null)
                {
                    catalogSync = new UPSyncCatalogs(this.DataStore);
                }

                catalogSync.SyncVariableCatalogs(catalogDef.ToObject <List <object> >());
            }

            var configurationDef = dataDict.ValueOrDefault("configuration") as JObject;

            if (configurationDef != null)
            {
                // DDLogCRequest("Import CONFIGURATION");
                this.Logger.LogDebug("Import CONFIGURATION", LogFlag.LogRequests);
                var configurationSync = new UPSyncConfiguration(this.ConfigStore);
                configurationSync.SyncWithConfigurationDefinition(configurationDef.ToObject <Dictionary <string, object> >());

                if (fullSync)
                {
                    var v = this.ConfigStore.ConfigValue("System.iOSServerTimeZone");
                    if (!string.IsNullOrEmpty(v))
                    {
                        this.DataStore.SetTimeZoneUtcDifference(v, 0);
                    }
                }
            }

            bool isEnterprise = false;
            var  licenseDef   = dataDict.ValueOrDefault("licenseInfo") as JObject;

            if (licenseDef != null)
            {
                // DDLogCRequest("Import LICENSEINFO");
                this.Logger.LogDebug("Import LICENSEINFO", LogFlag.LogRequests);
                Dictionary <string, object> licenseDefDictionary = licenseDef.ToObject <Dictionary <string, object> >();
                isEnterprise = bool.Parse(licenseDefDictionary.ValueOrDefault("IsEnterpriseVersion").ToString());
#if PORTING
                NSUserDefaults.StandardUserDefaults().SetBoolForKey(isEnterprise.BoolValue, "System.isEnterprise");
                NSUserDefaults.StandardUserDefaults().Synchronize();
#endif
            }

            var recordDef = dataDict.ValueOrDefault("records") as JArray;

            if (recordDef != null)
            {
                // DDLogCRequest("Import RECORDS");
                this.Logger.LogDebug("Import RECORDS", LogFlag.LogRequests);
                var recordSyncResult =
                    UPCRMRecordSync.SyncRecordSetDefinitionsCrmDataStore(recordDef.ToObject <List <object> >(), this.DataStore, isEnterprise);
                if (recordSyncResult.Successful)
                {
                    this.RecordCount += recordSyncResult.RecordCount;
                }
                else
                {
                    return(recordSyncResult.ReturnCode);
                }
            }

            var queryDef = dataDict.ValueOrDefault("queries");
            if (queryDef != null)
            {
                var querySync = new UPSyncQuery(this.DataStore);
                querySync.SyncWithQueryDefinition((List <object>)queryDef);
            }

            return(0);
        }
Example #33
0
 public UserSettings()
 {
     _defaults = NSUserDefaults.StandardUserDefaults;
 }
Example #34
0
            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;
                }
                }
            }
Example #35
0
 public Storage()
 {
     userDefaults = NSUserDefaults.StandardUserDefaults;
 }
Example #36
0
 public Storage()
 {
     _preferences = NSUserDefaults.StandardUserDefaults;
 }
Example #37
0
 public UISettings()
 {
     defaults = NSUserDefaults.StandardUserDefaults;
 }
Example #38
0
 public override bool OpenUrl (UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
 {
     if (systemVersion > minVersionWidget) {
         if (url.AbsoluteString.Contains (WidgetUpdateService.TodayUrlPrefix)) {
             var widgetManager = ServiceContainer.Resolve<WidgetSyncManager>();
             if (url.AbsoluteString.Contains (WidgetUpdateService.StartEntryUrlPrefix)) {
                 widgetManager.StartStopTimeEntry();
             } else {
                 var nsUserDefaults = new NSUserDefaults ("group.com.toggl.timer", NSUserDefaultsType.SuiteName);
                 var guid = nsUserDefaults.StringForKey (WidgetUpdateService.StartedEntryKey);
                 widgetManager.ContinueTimeEntry (Guid.Parse (guid));
             }
             return true;
         }
     }
     return SignIn.SharedInstance.HandleUrl (url, sourceApplication, annotation);
 }
 /// <summary>
 /// Constructor retrieves user defaults to display if this view appears in the Settings screen.
 /// </summary>
 /// <param name="handle"></param>
 public UITableViewControllerServerConnect(IntPtr handle) : base(handle)
 {
     userDefaults      = NSUserDefaults.StandardUserDefaults;
     defaultServerName = userDefaults.StringForKey(strings.defaultsServerNameHestia);
     defaultIP         = userDefaults.StringForKey(strings.defaultsIpHestia);
 }
		void SetElementValueFromDefaults(CheckboxElement e, NSUserDefaults defs, string key, bool defaultVal)
		{
			var value = defs.DataForKey (key);
			if (value == null)
				e.Value = defaultVal;
			else
				e.Value = defs.BoolForKey(key);
		}
Example #41
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:Crex.tvOS.ApplePreferences"/> class.
 /// </summary>
 public ApplePreferences()
 {
     Preferences = NSUserDefaults.StandardUserDefaults;
 }
 public override void ViewDidLoad()
 {
     base.ViewDidLoad ();
     userDefs = NSUserDefaults.StandardUserDefaults;
 }
Example #43
0
 // Constructor
 public MacPreferencesProvider() : base()
 {
     defaults = new NSUserDefaults();
 }