Avoid initial version pinning

CHANGELOG.md

@@ -1,3 +1,30 @@
+## 1.11.2 (YYYY-MM-DD)
+
+### Enhancements
+* None.
+
+### Fixed
+* `Realm.getNumberOfActiveVersions` now returns the actual number of active versions. (Core issue [#6960](https://github.com/realm/realm-core/pull/6960))
+* Removed pin on the initial realm version after opening a Realm. (Issue [#1519](https://github.com/realm/realm-kotlin/pull/1519))
+
+### Compatibility
+* File format: Generates Realms with file format v23.
+* Realm Studio 13.0.0 or above is required to open Realms created by this version.
+* This release is compatible with the following Kotlin releases:
+  * Kotlin 1.8.0 and above. The K2 compiler is not supported yet.
+  * Ktor 2.1.2 and above.
+  * Coroutines 1.7.0 and above.
+  * AtomicFu 0.18.3 and above.
+  * The new memory model only. See https://github.com/realm/realm-kotlin#kotlin-memory-model-and-coroutine-compatibility
+* Minimum Kbson 0.3.0.
+* Minimum Gradle version: 6.8.3.
+* Minimum Android Gradle Plugin version: 4.1.3.
+* Minimum Android SDK: 16.
+
+### Internal
+* Updated to Realm Core 13.20.0, commit a3717e492ec606e42995169cf706a82fc1cd0698.
+
+
 ## 1.11.1 (2023-09-07)
 
 ### Enhancements

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/LiveRealm.kt

@@ -99,7 +99,7 @@ internal abstract class LiveRealm(
     internal fun gcTrackedSnapshot(): FrozenRealmReference {
         return snapshotLock.withLock {
             _snapshot.value.also { snapshot ->
-                if (_closeSnapshotWhenAdvancing) {
+                if (_closeSnapshotWhenAdvancing && !snapshot.isClosed()) {
                     log.trace("${this@LiveRealm} ENABLE-TRACKING ${snapshot.version()}")
                     _closeSnapshotWhenAdvancing = false
                 }

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmImpl.kt

@@ -19,6 +19,7 @@ package io.realm.kotlin.internal
 import io.realm.kotlin.Configuration
 import io.realm.kotlin.MutableRealm
 import io.realm.kotlin.Realm
+import io.realm.kotlin.VersionId
 import io.realm.kotlin.dynamic.DynamicRealm
 import io.realm.kotlin.internal.dynamic.DynamicRealmImpl
 import io.realm.kotlin.internal.interop.RealmInterop
@@ -83,7 +84,8 @@ public class RealmImpl private constructor(
     internal val realmStateFlow =
         MutableSharedFlow<State>(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
 
-    private var _realmReference: AtomicRef<FrozenRealmReference?> = atomic(null)
+    // Holds the initial realm reference until the notifier or writer can provide with a newer snapshot.
+    private var _initialRealmReference: AtomicRef<FrozenRealmReference?> = atomic(null)
     private val realmReferenceLock = SynchronizableObject()
 
     /**
@@ -95,12 +97,6 @@ public class RealmImpl private constructor(
     override val realmReference: FrozenRealmReference
         get() = realmReference()
 
-    // TODO Bit of an overkill to have this as we are only catching the initial frozen version.
-    //  Maybe we could just rely on the notifier to issue the initial frozen version, but that
-    //  would require us to sync that up. Didn't address this as we already have a todo on fixing
-    //  constructing the initial frozen version in the initialization of updatableRealm.
-    private val versionTracker = VersionTracker(this, log)
-
     // Injection point for synchronized Realms. This property should only be used to hold state
     // required by synchronized realms. See `SyncedRealmContext` for more details.
     public var syncContext: AtomicRef<Any?> = atomic(null)
@@ -131,8 +127,7 @@ public class RealmImpl private constructor(
                 }
                 val (frozenReference, fileCreated) = configuration.openRealm(this@RealmImpl)
                 realmFileCreated = assetFileCopied || fileCreated
-                versionTracker.trackAndCloseExpiredReferences(frozenReference)
-                _realmReference.value = frozenReference
+                _initialRealmReference.value = frozenReference
                 configuration.initializeRealmData(this@RealmImpl, realmFileCreated)
             }
 
@@ -226,39 +221,46 @@ public class RealmImpl private constructor(
         return notifier.registerObserver(t)
     }
 
+    @Suppress("ComplexCondition", "ReturnCount")
     public fun realmReference(): FrozenRealmReference {
         realmReferenceLock.withLock {
-            val value1 = _realmReference.value
-            // We don't consider advancing the version if is is already closed.
-            value1?.let {
-                if (it.isClosed()) return it
+            val initialRealmReference = _initialRealmReference.value
+            val notifierVersion = notifier.version
+            val writerVersion = writer.version
+
+            if (initialRealmReference != null) {
+                if (initialRealmReference.isClosed()) return initialRealmReference
+
+                // Consider versions of current realm, notifier and writer to identify if we should
+                // advance the user facing realms version to a newer frozen snapshot.
+                val initialRealmVersion = initialRealmReference.version()
+
+                // Check if there is a newer version than the initial snapshot available.
+                if (
+                    (notifierVersion == null || notifierVersion <= initialRealmVersion) &&
+                    (writerVersion == null || writerVersion <= initialRealmVersion)
+                ) return initialRealmReference
+
+                // There is a newer snapshot available. Close the initial one manually, from now on
+                // we rely on the notifier and writer snapshots.
+                initialRealmReference.close()
+                _initialRealmReference.value = null
             }
 
-            // Consider versions of current realm, notifier and writer to identify if we should
-            // advance the user facing realms version to a newer frozen snapshot.
-            val version = value1?.version()
-            val notifierSnapshot = notifier.version
-            val writerSnapshot = writer.version
+            // Find whether the notifier or writer has the latest snapshot.
+            val newest: LiveRealmHolder<LiveRealm> =
+                if (writerVersion != null && (notifierVersion == null || writerVersion > notifierVersion))
+                    writer
+                else
+                    notifier
 
-            var newest: LiveRealmHolder<LiveRealm>? = null
-            if (notifierSnapshot != null && version != null && notifierSnapshot > version) {
-                newest = notifier
-            }
-            @Suppress("ComplexCondition")
-            if (writerSnapshot != null && version != null && ((writerSnapshot > version) || (notifierSnapshot != null && writerSnapshot > notifierSnapshot))) {
-                newest = writer
-            }
-            if (newest != null) {
-                _realmReference.value = newest.snapshot
-                log.debug("$this ADVANCING $version -> ${_realmReference.value?.version()}")
-            }
+            return newest.snapshot ?: sdkError("Accessing realmReference before realm has been opened")
         }
-        return _realmReference.value ?: sdkError("Accessing realmReference before realm has been opened")
     }
 
     public fun activeVersions(): VersionInfo {
-        val mainVersions: VersionData? = _realmReference.value?.let { VersionData(it.uncheckedVersion(), versionTracker.versions()) }
-        return VersionInfo(mainVersions, notifier.versions(), writer.versions())
+        val initialVersion: VersionId? = _initialRealmReference.value?.uncheckedVersion()
+        return VersionInfo(initialVersion, notifier.versions(), writer.versions())
     }
 
     override fun close() {
@@ -267,10 +269,12 @@ public class RealmImpl private constructor(
         writer.checkInTransaction("Cannot close the Realm while inside a transaction block")
         runBlocking {
             realmPointerMutex.withLock {
+                _initialRealmReference.value?.let { reference ->
+                    if (!reference.isClosed()) reference.close()
+                }
                 writer.close()
                 realmScope.cancel()
                 notifier.close()
-                versionTracker.close()
                 // The local realmReference is pointing to a realm reference managed by either the
                 // version tracker, writer or notifier, so it is already closed
                 super.close()

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/VersionInfo.kt

@@ -22,7 +22,17 @@ import io.realm.kotlin.VersionId
  * Version meta data for an overall [Realm]-instance with [VersionData] for the user-facing [Realm]
  * and the underlying [SuspendableNotifier]'s and [SuspendableWriter]'s live realms.
  */
-public data class VersionInfo(val main: VersionData?, val notifier: VersionData?, val writer: VersionData?) {
-    val all: Set<VersionId> = setOf(main, notifier, writer).mapNotNull { it?.versions }.flatten().toSet()
-    val allTracked: Set<VersionId> = setOf(main, notifier, writer).mapNotNull { it?.active }.flatten().toSet()
+public data class VersionInfo(
+    val initialVersion: VersionId?,
+    val notifier: VersionData?,
+    val writer: VersionData?,
+) {
+    val all: Set<VersionId> = (
+        setOf(notifier, writer).mapNotNull { it?.versions }
+            .flatten() + listOfNotNull(initialVersion)
+        ).toSet()
+    val allTracked: Set<VersionId> = (
+        setOf(notifier, writer).mapNotNull { it?.active }
+            .flatten() + listOfNotNull(initialVersion)
+        ).toSet()
 }

packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/VersionTrackingTests.kt

@@ -109,9 +109,9 @@ class VersionTrackingTests {
         // Until we actually query the object
         realm.query<Sample>().find()
         realm.activeVersions().run {
-            assertEquals(2, allTracked.size, toString())
+            assertEquals(1, allTracked.size, toString())
             assertNotNull(writer, toString())
-            assertEquals(1, writer?.active?.size, toString())
+            assertEquals(0, writer?.active?.size, toString())
         }
     }