Classes with Finalizable fields implements Finalizable

Classes that implements Finalizable:
* App,
* FlexibleSyncConfiguration,
* HandleBase,
* Realm,
* RealmEntity,
* RealmList,
* RealmResults,
* Subscription,
* SubscriptionSet, and
* User,

The corresponding XInternal extension classes implements a keepAlive
function to ensure finalizable fields always live as long as their
finalizable parent. This is workaround for:
dart-lang/sdk#49643

Resolves: #581, resolves: #582

lib/src/app.dart

@@ -15,6 +15,7 @@
 // limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////////
+import 'dart:ffi';
 import 'dart:io';
 
 import 'package:meta/meta.dart';
@@ -108,7 +109,7 @@ class AppConfiguration {
 /// * Register uses and perform various user-related operations through authentication providers
 /// * Synchronize data between the local device and a remote Realm App with Synchronized Realms
 /// {@category Application}
-class App {
+class App implements Finalizable {
   final AppHandle _handle;
 
   /// The id of this application. This is the same as the appId in the [AppConfiguration] used to
@@ -179,6 +180,11 @@ enum MetadataPersistenceMode {
 
 /// @nodoc
 extension AppInternal on App {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+  }
+
   AppHandle get handle => _handle;
 
   static App create(AppHandle handle) => App._(handle);

lib/src/configuration.dart

@@ -16,13 +16,15 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+import 'dart:ffi';
 import 'dart:io';
 
 import 'package:path/path.dart' as _path;
 
 import 'native/realm_core.dart';
 import 'realm_class.dart';
 import 'init.dart';
+import 'user.dart';
 
 /// The signature of a callback used to determine if compaction
 /// should be attempted.
@@ -47,7 +49,7 @@ typedef InitialDataCallback = void Function(Realm realm);
 
 /// Configuration used to create a [Realm] instance
 /// {@category Configuration}
-abstract class Configuration {
+abstract class Configuration implements Finalizable {
   /// The default realm filename to be used.
   static String get defaultRealmName => _path.basename(defaultRealmPath);
   static set defaultRealmName(String name) => defaultRealmPath = _path.join(_path.dirname(defaultRealmPath), _path.basename(name));
@@ -278,6 +280,11 @@ class FlexibleSyncConfiguration extends Configuration {
 }
 
 extension FlexibleSyncConfigurationInternal on FlexibleSyncConfiguration {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    user.keepAlive();
+  }
+
   SessionStopPolicy get sessionStopPolicy => _sessionStopPolicy;
   set sessionStopPolicy(SessionStopPolicy value) => _sessionStopPolicy = value;
 }

lib/src/credentials.dart

@@ -17,6 +17,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 import 'dart:convert';
+import 'dart:ffi';
 
 import 'native/realm_core.dart';
 import 'app.dart';
@@ -55,7 +56,7 @@ enum AuthProviderType {
 
 /// A class, representing the credentials used for authenticating a [User]
 /// {@category Application}
-class Credentials {
+class Credentials implements Finalizable {
   final RealmAppCredentialsHandle _handle;
   final AuthProviderType provider;
 
@@ -109,13 +110,18 @@ class Credentials {
 
 /// @nodoc
 extension CredentialsInternal on Credentials {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+  }
+
   RealmAppCredentialsHandle get handle => _handle;
 }
 
 /// A class, encapsulating functionality for users, logged in with [Credentials.emailPassword()].
 /// It is always scoped to a particular app.
 /// {@category Application}
-class EmailPasswordAuthProvider {
+class EmailPasswordAuthProvider implements Finalizable {
   final App app;
 
   /// Create a new EmailPasswordAuthProvider for the [app]
@@ -164,5 +170,10 @@ class EmailPasswordAuthProvider {
 }
 
 extension EmailPasswordAuthProviderInternal on EmailPasswordAuthProvider {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    app.keepAlive();
+  }
+
   static EmailPasswordAuthProvider create(App app) => EmailPasswordAuthProvider(app);
 }

lib/src/list.dart

@@ -145,6 +145,14 @@ extension RealmListOfObject<T extends RealmObject> on RealmList<T> {
 
 /// @nodoc
 extension RealmListInternal<T extends Object> on RealmList<T> {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    final self = this;
+    if (self is ManagedRealmList<T>) {
+      self._handle.keepAlive();
+    }
+  }
+
   ManagedRealmList<T> asManaged() => this is ManagedRealmList<T> ? this as ManagedRealmList<T> : throw RealmStateError('$this is not managed');
 
   RealmListHandle get handle => asManaged()._handle;

lib/src/native/realm_core.dart

@@ -1681,7 +1681,7 @@ class LastError {
 }
 
 void _traceFinalization(Object o) {
-  Realm.logger.log(RealmLogLevel.info, 'Finalizing: $o');
+  Realm.logger.log(RealmLogLevel.trace, 'Finalizing: $o');
 }
 
 final _debugFinalizer = Finalizer<Object>(_traceFinalization);
@@ -1691,6 +1691,9 @@ final _nativeFinalizer = NativeFinalizer(_realmLib.addresses.realm_release);
 abstract class HandleBase<T extends NativeType> implements Finalizable {
   final Pointer<T> _pointer;
 
+  @pragma('vm:never-inline')
+  void keepAlive() {}
+
   HandleBase(this._pointer, int size) {
     _nativeFinalizer.attach(this, _pointer.cast(), detach: this, externalSize: size);
     assert(() {
@@ -1755,13 +1758,13 @@ class ReleasableHandle<T extends NativeType> extends HandleBase<T> {
       return;
     }
     _nativeFinalizer.detach(this);
+    _realmLib.realm_release(_pointer.cast());
+    released = true;
     assert(() {
-      _traceFinalization(_pointer);
       _debugFinalizer.detach(this);
+      _traceFinalization(_pointer);
       return true;
     }());
-    _realmLib.realm_release(_pointer.cast());
-    released = true;
   }
 }
 

lib/src/realm_class.dart

@@ -17,6 +17,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 import 'dart:async';
+import 'dart:ffi';
 import 'dart:io';
 
 import 'package:logging/logging.dart';
@@ -84,7 +85,7 @@ export 'session.dart' show Session, SessionState, ConnectionState, ProgressDirec
 /// A [Realm] instance represents a `Realm` database.
 ///
 /// {@category Realm}
-class Realm {
+class Realm implements Finalizable {
   final Map<Type, RealmMetadata> _metadata = <Type, RealmMetadata>{};
   final RealmHandle _handle;
 
@@ -237,6 +238,11 @@ class Realm {
     _subscriptions?.handle.release();
     _subscriptions = null;
 
+    final c = config;
+    if (c is FlexibleSyncConfiguration) {
+      final i = c.user.app.id;
+    }
+
     realmCore.closeRealm(this);
   }
 
@@ -327,9 +333,9 @@ class Realm {
     ..level = RealmLogLevel.info
     ..onRecord.listen((event) => print(event));
 
-  /// Used to shutdown Realm and allow the process to correctly release native resources and exit. 
-  /// 
-  /// Disclaimer: This method is mostly needed on Dart standalone and if not called the Dart probram will hang and not exit. 
+  /// Used to shutdown Realm and allow the process to correctly release native resources and exit.
+  ///
+  /// Disclaimer: This method is mostly needed on Dart standalone and if not called the Dart probram will hang and not exit.
   /// This is a workaround of a Dart VM bug and will be removed in a future version of the SDK.
   static void shutdown() => scheduler.stop();
 }
@@ -364,6 +370,15 @@ class Transaction {
 
 /// @nodoc
 extension RealmInternal on Realm {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+    final c = config;
+    if (c is FlexibleSyncConfiguration) {
+      c.keepAlive();
+    }
+  }
+
   RealmHandle get handle => _handle;
 
   static Realm getUnowned(Configuration config, RealmHandle handle) {

lib/src/realm_object.dart

@@ -17,6 +17,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 import 'dart:async';
+import 'dart:ffi';
 
 import 'list.dart';
 import 'native/realm_core.dart';
@@ -178,7 +179,7 @@ class RealmCoreAccessor implements RealmAccessor {
   }
 }
 
-mixin RealmEntity {
+mixin RealmEntity implements Finalizable {
   Realm? _realm;
 
   /// The [Realm] instance this object belongs to.
@@ -189,6 +190,11 @@ mixin RealmEntity {
 }
 
 extension RealmEntityInternal on RealmEntity {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _realm?.keepAlive();
+  }
+
   void setRealm(Realm value) => _realm = value;
 }
 

lib/src/results.dart

@@ -18,6 +18,7 @@
 
 import 'dart:async';
 import 'dart:collection' as collection;
+import 'dart:ffi';
 
 import 'collections.dart';
 import 'native/realm_core.dart';
@@ -27,7 +28,7 @@ import 'realm_class.dart';
 /// added to or deleted from the Realm that match the underlying query.
 ///
 /// {@category Realm}
-class RealmResults<T extends RealmObject> extends collection.IterableBase<T> {
+class RealmResults<T extends RealmObject> extends collection.IterableBase<T> implements Finalizable {
   final RealmResultsHandle _handle;
 
   /// The Realm instance this collection belongs to.
@@ -81,6 +82,11 @@ class RealmResults<T extends RealmObject> extends collection.IterableBase<T> {
 /// @nodoc
 //RealmResults package internal members
 extension RealmResultsInternal on RealmResults {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+  }
+
   RealmResultsHandle get handle => _handle;
 
   static RealmResults<T> create<T extends RealmObject>(RealmResultsHandle handle, Realm realm) {

lib/src/subscription.dart

@@ -18,6 +18,7 @@
 
 import 'dart:core';
 import 'dart:collection';
+import 'dart:ffi';
 
 import 'native/realm_core.dart';
 import 'realm_class.dart';
@@ -26,7 +27,7 @@ import 'realm_class.dart';
 /// evaluate the query that the app subscribed to and will send data
 /// that matches it as well as remove data that no longer does.
 /// {@category Sync}
-class Subscription {
+class Subscription implements Finalizable {
   final SubscriptionHandle _handle;
 
   Subscription._(this._handle);
@@ -64,6 +65,11 @@ class Subscription {
 }
 
 extension SubscriptionInternal on Subscription {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+  }
+
   SubscriptionHandle get handle => _handle;
   ObjectId get id => _id;
 }
@@ -121,7 +127,7 @@ enum SubscriptionSetState {
 /// Realm is an expensive operation serverside, even if there's very little data that needs
 /// downloading.
 /// {@category Sync}
-abstract class SubscriptionSet with IterableMixin<Subscription> {
+abstract class SubscriptionSet with IterableMixin<Subscription> implements Finalizable {
   final Realm _realm;
   SubscriptionSetHandle _handle;
 
@@ -204,6 +210,12 @@ abstract class SubscriptionSet with IterableMixin<Subscription> {
 }
 
 extension SubscriptionSetInternal on SubscriptionSet {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _realm.keepAlive();
+    _handle.keepAlive();
+  }
+
   Realm get realm => _realm;
   SubscriptionSetHandle get handle => _handle;
 

lib/src/user.dart

@@ -29,14 +29,14 @@ import './app.dart';
 /// locally on the device, and should be treated as sensitive data.
 /// {@category Application}
 class User {
-  final App? _app;
+  App? _app;
   final UserHandle _handle;
 
   /// The [App] with which the [User] is associated with.
   App get app {
     // The _app field may be null when we're retrieving a user from the session
     // rather than from the app.
-    return _app ?? AppInternal.create(realmCore.userGetApp(_handle));
+    return _app ??= AppInternal.create(realmCore.userGetApp(_handle));
   }
 
   User._(this._handle, this._app);
@@ -190,6 +190,12 @@ extension UserIdentityInternal on UserIdentity {
 
 /// @nodoc
 extension UserInternal on User {
+  @pragma('vm:never-inline')
+  void keepAlive() {
+    _handle.keepAlive();
+    _app?.keepAlive();
+  }
+
   UserHandle get handle => _handle;
 
   static User create(UserHandle handle, [App? app]) => User._(handle, app);