private void skinsChanged(IRealmCollection <SkinInfo> sender, ChangeSet changes, Exception error) { // This can only mean that realm is recycling, else we would see the protected skins. // Because we are using `Live<>` in this class, we don't need to worry about this scenario too much. if (!sender.Any()) { return; } int protectedCount = sender.Count(s => s.Protected); // For simplicity repopulate the full list. // In the future we should change this to properly handle ChangeSet events. dropdownItems.Clear(); foreach (var skin in sender) { dropdownItems.Add(skin.ToLive(realm)); } dropdownItems.Insert(protectedCount, random_skin_info); Schedule(() => { skinDropdown.Items = dropdownItems; updateSelectedSkinFromConfig(); }); }
public RealmObservableCollection(IRealmCollection <TRealmObject> realmCollection, Func <TRealmObject, TObject> converter) : base(realmCollection.Select(converter)) { _realmCollection = realmCollection; _converter = converter; realmCollection.CollectionChanged += ChangesHandler; }
public GraphViewModel() { Today = TodoService.GetTodayList(); Yesterday = TodoService.GetYesterdayList(); ThisWeek = TodoService.GetThisWeekList(); LastWeek = TodoService.GetLastWeekList(); LastMonth = TodoService.GetLastMonthList(); }
protected IRealmCollection <T> Freeze <T>(IRealmCollection <T> collection) where T : RealmObject { var result = collection.Freeze(); CleanupOnTearDown(result.Realm); return(result); }
public GraphViewModel() { _service = new TodoService(); Today = _service.GetTodayList(); Yesterday = _service.GetYesterdayList(); ThisWeek = _service.GetThisWeekList(); LastWeek = _service.GetLastWeekList(); LastMonth = _service.GetLastMonthList(); }
/// <summary> /// Register a callback to be invoked each time this <see cref="T:Realms.IRealmCollection`1" /> changes. /// </summary> /// <remarks> /// <para> /// This adds osu! specific thread and managed state safety checks on top of <see cref="IRealmCollection{T}.SubscribeForNotifications"/>. /// </para> /// <para> /// The first callback will be invoked with the initial <see cref="T:Realms.IRealmCollection`1" /> after the asynchronous query completes, /// and then called again after each write transaction which changes either any of the objects in the collection, or /// which objects are in the collection. The <c>changes</c> parameter will /// be <c>null</c> the first time the callback is invoked with the initial results. For each call after that, /// it will contain information about which rows in the results were added, removed or modified. /// </para> /// <para> /// If a write transaction did not modify any objects in this <see cref="T:Realms.IRealmCollection`1" />, the callback is not invoked at all. /// If an error occurs the callback will be invoked with <c>null</c> for the <c>sender</c> parameter and a non-<c>null</c> <c>error</c>. /// Currently the only errors that can occur are when opening the <see cref="T:Realms.Realm" /> on the background worker thread. /// </para> /// <para> /// At the time when the block is called, the <see cref="T:Realms.IRealmCollection`1" /> object will be fully evaluated /// and up-to-date, and as long as you do not perform a write transaction on the same thread /// or explicitly call <see cref="M:Realms.Realm.Refresh" />, accessing it will never perform blocking work. /// </para> /// <para> /// Notifications are delivered via the standard event loop, and so can't be delivered while the event loop is blocked by other activity. /// When notifications can't be delivered instantly, multiple notifications may be coalesced into a single notification. /// This can include the notification with the initial collection. /// </para> /// </remarks> /// <param name="collection">The <see cref="IRealmCollection{T}"/> to observe for changes.</param> /// <param name="callback">The callback to be invoked with the updated <see cref="T:Realms.IRealmCollection`1" />.</param> /// <returns> /// A subscription token. It must be kept alive for as long as you want to receive change notifications. /// To stop receiving notifications, call <see cref="M:System.IDisposable.Dispose" />. /// /// May be null in the case the provided collection is not managed. /// </returns> /// <seealso cref="M:Realms.CollectionExtensions.SubscribeForNotifications``1(System.Collections.Generic.IList{``0},Realms.NotificationCallbackDelegate{``0})" /> /// <seealso cref="M:Realms.CollectionExtensions.SubscribeForNotifications``1(System.Linq.IQueryable{``0},Realms.NotificationCallbackDelegate{``0})" /> public static IDisposable?QueryAsyncWithNotifications <T>(this IRealmCollection <T> collection, NotificationCallbackDelegate <T> callback) where T : RealmObjectBase { if (!RealmAccess.CurrentThreadSubscriptionsAllowed) { throw new InvalidOperationException($"Make sure to call {nameof(RealmAccess)}.{nameof(RealmAccess.RegisterForNotifications)}"); } return(collection.SubscribeForNotifications(callback)); }
private void OnCollectionUpdated(IRealmCollection <Task> sender, ChangeSet changes, Exception error) { //very naive implementation :) //OK for demo purposes Tasks.Clear(); foreach (var item in sender) { Tasks.Add(new TaskViewModel(item)); } }
public static IDisposable?QueryAsyncWithNotifications <T>(this IRealmCollection <T> collection, NotificationCallbackDelegate <T> callback) where T : RealmObjectBase { // Subscriptions can only work on the main thread. if (!ThreadSafety.IsUpdateThread) { throw new InvalidOperationException("Cannot subscribe for realm notifications from a non-update thread."); } return(collection.SubscribeForNotifications(callback)); }
private void beatmapsChanged(IRealmCollection <BeatmapSetInfo> items, ChangeSet changes, Exception ___) { if (changes?.InsertedIndices == null) { return; } foreach (int c in changes.InsertedIndices) { beatmapUpdated(items[c]); } }
internal virtual void ObjectChanged(IRealmCollection <RealmObject> sender, ChangeSet changes, Exception error) //internal for Tests { if (changes == null) { return; } if (_skipObjectChanges) { return; } lock (_objectChangedLock) { try { using (var realmius = CreateRealmius()) { using (var realm = _realmFactoryMethod()) { realmius.Refresh(); foreach (var changesInsertedIndex in changes.InsertedIndices) { var obj = (IRealmiusObjectClient)sender[changesInsertedIndex]; HandleObjectChanged(obj, realmius, realm); } foreach (var changesModifiedIndex in changes.ModifiedIndices) { var obj = (IRealmiusObjectClient)sender[changesModifiedIndex]; HandleObjectChanged(obj, realmius, realm); } //delete can not be handled that way /* * foreach (var changesDeletedIndex in changes.DeletedIndices) * { * var obj = (IRealmiusObjectClient)sender[changesDeletedIndex]; * * HandleObjectChanged(obj, realmius, realm, isDeleted: true); * }*/ } } } catch (Exception e) { Logger.Exception(e); throw; } } }
private void OnChange(IRealmCollection <T> sender, ChangeSet change, Exception error) { if (error != null) { Realm.NotifyError(error); } else if (!sender.IsValid) { RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); } else if (change != null) { if (change.Moves.Length > 0 && change.Moves.Length == change.InsertedIndices.Length && change.Moves.Length == change.DeletedIndices.Length) { var ordered = change.Moves.OrderBy(m => m.From); var movedPositions = -1; var isConsecutiveMove = true; foreach (var item in ordered) { if (movedPositions == -1) { movedPositions = item.To - item.From; } else if (item.To - item.From != movedPositions) { isConsecutiveMove = false; break; } } if (isConsecutiveMove) { var initialItem = ordered.First(); var movedItems = Enumerable.Range(initialItem.To, change.Moves.Length) .Select(i => sender[i]) .ToList(); RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, movedItems, initialItem.To, initialItem.From)); } else { RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); } RaisePropertyChanged(); return; } var raiseRemoved = TryGetConsecutive(change.DeletedIndices, _ => default, out var removedItems, out var removedStartIndex);
void UpdateTodos(IRealmCollection <TodoItem> sender, ChangeSet changes, Exception error) { if (error != null) { return; } if (changes == null) { var todos = sender.Select(ToModel).ToList(); Todos = new ObservableCollection <TodoModel>(todos); return; } for (int i = 0; i < changes.DeletedIndices?.Length; i++) { Todos.RemoveAt(changes.DeletedIndices[i]); } for (int i = 0; i < changes.InsertedIndices?.Length; i++) { var item = sender[changes.InsertedIndices[i]]; Todos.Insert(changes.InsertedIndices[i], ToModel(item)); } for (int i = 0; i < changes.ModifiedIndices?.Length; i++) { var item = sender[changes.ModifiedIndices[i]]; var model = Todos[changes.ModifiedIndices[i]]; model.Title = item.Title; model.Deadline = item.Deadline; model.Done = item.Done; model.HasDeadline = item.Deadline.HasValue; } for (int i = 0; i < changes.Moves?.Length; i++) { var move = changes.Moves[i]; var temp = Todos[move.From]; Todos[move.From] = Todos[move.To]; Todos[move.To] = temp; } }
private void beatmapsChanged(IRealmCollection <BeatmapSetInfo> sender, ChangeSet?changes, Exception error) { currentlyLoadedBeatmaps.Text = FirstRunSetupBeatmapScreenStrings.CurrentlyLoadedBeatmaps(sender.Count); if (sender.Count == 0) { currentlyLoadedBeatmaps.FadeColour(colours.Red1, 500, Easing.OutQuint); } else if (changes != null && (changes.DeletedIndices.Any() || changes.InsertedIndices.Any())) { currentlyLoadedBeatmaps.FadeColour(colours.Yellow) .FadeColour(OverlayColourProvider.Content2, 1500, Easing.OutQuint); currentlyLoadedBeatmaps.ScaleTo(1.1f) .ScaleTo(1, 1500, Easing.OutQuint); } }
private void beatmapsChanged(IRealmCollection <BeatmapSetInfo> sender, ChangeSet changes, Exception error) { if (changes == null) { beatmapSets.Clear(); // must use AddRange to avoid RearrangeableList sort overhead per add op. beatmapSets.AddRange(sender.Select(b => b.ToLive(realm))); return; } foreach (int i in changes.InsertedIndices) { beatmapSets.Insert(i, sender[i].ToLive(realm)); } foreach (int i in changes.DeletedIndices.OrderByDescending(i => i)) { beatmapSets.RemoveAt(i); } }
private void OnChange(IRealmCollection <T> sender, ChangeSet change, Exception error) { if (error != null) { Realm.NotifyError(error); } else if (change != null) { IList removedItems; int removedStartIndex; var raiseRemoved = TryGetConsecutive(change.DeletedIndices, _ => default(T), out removedItems, out removedStartIndex); IList addedItems; int addedStartIndex; var raiseAdded = TryGetConsecutive(change.InsertedIndices, i => this[i], out addedItems, out addedStartIndex); if (raiseAdded || raiseRemoved) { if ((raiseAdded && raiseRemoved) || (raiseAdded && addedItems == null) || (raiseRemoved && removedItems == null)) { RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); return; } if (removedItems != null) { RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, removedStartIndex)); } if (addedItems != null) { RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, addedItems, addedStartIndex)); } } } }
private static void HandleNotificationCallbackDelegate <T>(ObservableCollection <T> messages, IQueryable <T> results, IRealmCollection <T> realmMessages, ChangeSet changes, Exception error) where T : RealmObject { var isFirstResponse = changes == null; if (isFirstResponse) { realmMessages.ForEach(messages.Add); } else { changes?.InsertedIndices.ForEach(i => messages.Insert(i, realmMessages[i])); changes?.ModifiedIndices.ForEach(i => messages[i] = realmMessages[i]); } }
protected ObservableGroupedCollection(IRealmCollection <TKey> collection, Func <TKey, TValue> converter) { _collection = collection; _converter = converter; }
public void GetCats() { _cats = _catService.GetCats(); }
public GroupedCollection(IRealmCollection<TKey> objects, Func<TKey, IRealmCollection<TValue>> valueSelector) : base(objects, o => new ObservableGrouping<TKey, TValue>(o, valueSelector)) { }
private void UploadRequestItemChanged(IRealmCollection <RealmObject> sender, ChangeSet changes, Exception error) { StartUploadTask(); }
private void UploadFileChanged(IRealmCollection <UploadFileInfo> sender, ChangeSet changes, Exception error) { UploadFiles(); }
private void skinChanged(IRealmCollection <T> sender, ChangeSet changes, Exception error) => invalidateCache();
internal static IGroupedCollection <TKey, TValue> ToGroupedCollection <TKey, TValue>(this IRealmCollection <TKey> collection, Func <TKey, IRealmCollection <TValue> > valueSelector) where TKey : RealmObject where TValue : RealmObject { return(new GroupedCollection <TKey, TValue>(collection, valueSelector)); }
public BackLinkApp() { realm = Realm.GetInstance("backlinks.realm"); allMessageThreads = (IRealmCollection <MessageThread>)realm.All <MessageThread>(); var messageCell = new DataTemplate(typeof(TextCell)); messageCell.SetBinding(TextCell.TextProperty, "Body"); messageCell.SetBinding(TextCell.DetailProperty, "Guid"); var messageListView = new ListView { ItemTemplate = messageCell, }; var threadCell = new DataTemplate(typeof(TextCell)); threadCell.SetBinding(TextCell.TextProperty, "Guid"); var messageThreadListView = new ListView { ItemsSource = allMessageThreads, ItemTemplate = threadCell }; messageThreadListView.ItemSelected += (sender, e) => { currentMessageThreadPriKey = (messageThreadListView.SelectedItem as MessageThread).Guid; currentMessageThread = (IRealmCollection <MessageThread>)realm.All <MessageThread>().Where((messageThread) => messageThread.Guid == currentMessageThreadPriKey); messageListView.ItemsSource = currentMessageThread?.FirstOrDefault()?.Messages; addMessageToThread.IsEnabled = currentMessageThread?.Count() > 0; }; addMessageThread = new Button { Text = "Add New MessageThread" }; addMessageThread.Clicked += (sender, e) => { realm.Write(() => { var messageThread = new MessageThread { Guid = Guid.NewGuid().ToString() }; realm.Add(messageThread); }); }; addMessageToThread = new Button { Text = "Add New Message to Thread", IsEnabled = false }; addMessageToThread.Clicked += (sender, e) => { realm.Write(() => { currentMessageThread = (IRealmCollection <MessageThread>)realm.All <MessageThread>().Where((messageThread) => messageThread.Guid == currentMessageThreadPriKey); var counter = currentMessageThread.FirstOrDefault().Messages.Count() + 1; var message = new Message { Guid = Guid.NewGuid().ToString(), Body = $"StackoverFlow:{counter}" }; currentMessageThread?.FirstOrDefault()?.Messages.Add(message); }); }; MainPage = new ContentPage { Content = new StackLayout { VerticalOptions = LayoutOptions.Center, Children = { addMessageThread, messageThreadListView, addMessageToThread, messageListView } } }; }