support realm refresh()

CHANGELOG.md

@@ -9,6 +9,7 @@
 ### Enhancements
 * Support setting `maxNumberOfActiveVersions` when creating a `Configuration`. ([#1036](https://github.com/realm/realm-dart/pull/1036))
 * Add List.move extension method that moves an element from one index to another. Delegates to ManagedRealmList.move for managed lists. This allows notifications to correctly report moves, as opposed to reporting moves as deletes + inserts. ([#1037](https://github.com/realm/realm-dart/issues/1037))
+* Add `Realm.refresh()` support. ([#1046](https://github.com/realm/realm-dart/pull/1046))
 * Support setting `shouldDeleteIfMigrationNeeded` when creating a `Configuration.local`. ([#1049](https://github.com/realm/realm-dart/issues/1049))
 
 ### Fixed

lib/src/native/realm_core.dart

@@ -764,8 +764,35 @@ class _RealmCore {
     _realmLib.invokeGetBool(() => _realmLib.realm_rollback(realm.handle._pointer), "Could not rollback write");
   }
 
-  void realmRefresh(Realm realm) {
+  bool realmRefresh(Realm realm) {
     _realmLib.invokeGetBool(() => _realmLib.realm_refresh(realm.handle._pointer), "Could not refresh");
+    //TODO: Remove this and return the correct result of calling `realm_refresh`.
+    //Currently there is a bug in C-API that does not return the refresh result correctly.
+    //Issue https://github.com/realm/realm-core/pull/6068
+    return true;
+  }
+
+  Future<void> realmRefreshAsync(Realm realm) {
+    final completer = Completer<void>();
+    final callback = Pointer.fromFunction<Void Function(Pointer<Void>)>(_realmRefreshAsyncCallback);
+    Pointer<Void> completerPtr = _realmLib.realm_dart_object_to_persistent_handle(completer);
+    Pointer<realm_refresh_callback_token> result = _realmLib.realm_add_realm_refresh_callback(
+        realm.handle._pointer, callback.cast(), completerPtr, _realmLib.addresses.realm_dart_delete_persistent_handle);
+
+    if (result == nullptr) {
+      return Future.value();
+    }
+
+    return completer.future;
+  }
+
+  static void _realmRefreshAsyncCallback(Pointer<Void> userdata) {
+    if (userdata == nullptr) {
+      return;
+    }
+
+    final completer = _realmLib.realm_dart_persistent_handle_to_object(userdata) as Completer<void>;
+    completer.complete();
   }
 
   RealmObjectMetadata getObjectMetadata(Realm realm, SchemaObject schema) {

lib/src/realm_class.dart

@@ -539,6 +539,21 @@ class Realm implements Finalizable {
       realm.close();
     }
   }
+
+  /// Update the `Realm` instance and outstanding objects to point to the most recent persisted version.
+  /// 
+  /// If another process or thread has made changes to the realm file, this causes
+  /// those changes to become visible in this realm instance.
+  /// Typically you don't need to call this method since Realm has auto-refresh built-in.
+  bool refresh() {
+    return realmCore.realmRefresh(this);
+  }
+
+  /// Returns a [Future] that will complete when the `Realm` is refreshed to the version which is the
+  /// latest version at the time when this method is called.
+  Future<void> refreshAsync() {
+    return realmCore.realmRefreshAsync(this);
+  }
 }
 
 /// Provides a scope to safely write data to a [Realm]. Can be created using [Realm.beginWrite] or

src/realm_dart.hpp

@@ -23,7 +23,6 @@
 #include <realm/util/functional.hpp>
 
 struct realm_dart_userdata_async {
-public:
     realm_dart_userdata_async(Dart_Handle handle, void* callback, realm_scheduler_t* scheduler)
     : handle(Dart_NewPersistentHandle_DL(handle))
     , dart_callback(callback)

test/realm_test.dart

@@ -1416,7 +1416,7 @@ Future<void> main([List<String>? args]) async {
 
   Future<int> createRealmForCompact(Configuration config) async {
     var realm = getRealm(config);
-    
+
     if (config is FlexibleSyncConfiguration) {
       realm.subscriptions.update((mutableSubscriptions) {
         mutableSubscriptions.add(realm.query<Product>("stringQueryField CONTAINS '$compactTest'"));
@@ -1425,7 +1425,7 @@ Future<void> main([List<String>? args]) async {
     }
 
     addDataForCompact(realm);
-    
+
     if (config is FlexibleSyncConfiguration) {
       await realm.syncSession.waitForDownload();
       await realm.syncSession.waitForUpload();
@@ -1439,7 +1439,7 @@ Future<void> main([List<String>? args]) async {
 
   void validateCompact(bool compacted, String realmPath, int beforeCompactSizeSize) async {
     expect(compacted, true);
-    final afterCompactSize  = await File(realmPath).stat().then((value) => value.size);
+    final afterCompactSize = await File(realmPath).stat().then((value) => value.size);
     expect(beforeCompactSizeSize, greaterThan(afterCompactSize));
   }
 
@@ -1455,7 +1455,7 @@ Future<void> main([List<String>? args]) async {
     final realm = getRealm(config);
   });
 
-   test('Realm - non existing realm can not be compacted', () async {
+  test('Realm - non existing realm can not be compacted', () async {
     var config = Configuration.local([Product.schema], path: p.join(Configuration.defaultStoragePath, "${generateRandomString(8)}.realm"));
     final compacted = Realm.compact(config);
     expect(compacted, false);
@@ -1553,8 +1553,7 @@ Future<void> main([List<String>? args]) async {
     final path = p.join(Configuration.defaultStoragePath, "${generateRandomString(8)}.realm");
     var user = await app.logIn(credentials);
     List<int> key = List<int>.generate(encryptionKeySize, (i) => random.nextInt(256));
-    final config =
-        Configuration.flexibleSync(user, [Product.schema], encryptionKey: key, path: path);
+    final config = Configuration.flexibleSync(user, [Product.schema], encryptionKey: key, path: path);
     final beforeCompactSize = await createRealmForCompact(config);
     user.logOut();
     Future<void>.delayed(Duration(seconds: 5));
@@ -1567,6 +1566,75 @@ Future<void> main([List<String>? args]) async {
     //test the realm can be opened.
     final realm = getRealm(Configuration.disconnectedSync([Product.schema], path: path, encryptionKey: key));
   });
+
+  test('Realm.refresh', () async {
+    final realm = getRealm(Configuration.local([Person.schema]));
+    final result = realm.refresh();
+    expect(result, true);
+  });
+
+  test('Realm.onRefresh sync transaction', () async {
+    final realm = getRealm(Configuration.local([Person.schema]));
+    var called = false;
+    final transaction = realm.beginWrite();
+    realm.refreshAsync().then((_) => called = true);
+    realm.add(Person("name"));
+    transaction.commit();
+
+    await Future<void>.delayed(Duration(milliseconds: 1));
+    expect(called, true, reason: "beginWrite onRefresh failed");
+
+    called = false;
+    realm.write(() {
+      realm.refreshAsync().then((_) => called = true);
+      realm.add(Person("name"));
+    });
+
+    await Future<void>.delayed(Duration(milliseconds: 1));
+    expect(called, true, reason: "write onRefresh failed");
+  });
+
+  test('Realm.onRefresh async transaction', () async {
+    final realm = getRealm(Configuration.local([Person.schema]));
+    bool called = false;
+    final transaction = await realm.beginWriteAsync();
+    realm.refreshAsync().then((_) => called = true);
+    realm.add(Person("name"));
+    await transaction.commitAsync();
+    expect(called, true);
+  });
+
+   test('Realm.onRefresh is called if registered outside a transaction', () async {
+    final realm = getRealm(Configuration.local([Person.schema]));
+    bool called = false;
+
+    realm.refreshAsync().then((_) => called = true);
+
+    realm.beginWrite().commit();
+
+    await Future<void>.delayed(Duration(milliseconds: 1));
+
+    expect(called, true);
+
+
+    realm.refreshAsync().then((_) => called = true);
+
+    realm.write(() {});
+
+    await Future<void>.delayed(Duration(milliseconds: 1));
+
+    expect(called, true);
+  });
+
+   test('Realm.onRefresh on frozen realm should be no-op', () async {
+    var realm = getRealm(Configuration.local([Person.schema]));
+    bool called = false;
+    realm = realm.freeze();
+
+    await Future.any([realm.refreshAsync().then((_) => called = true), Future<void>.delayed(Duration(milliseconds: 10))]);
+
+    expect(called, true);
+  });
 }
 
 List<int> generateEncryptionKey() {