wip implement pattern

TODO next up: we need to also keep alive things that we're depending on
in order to be delivered events — or are we doing this already just by
keeping the channel around which thus keeps objects around?

TODO next up write some tests

Note that we have been able to remove the "keep channel alive" code from
integration tests now (TODO I still don't understand why the channel
would have been dying before; wouldn't the realtime instance have kept
it around? Ah, no — I think that we could have probably even removed it
in the previous PR, because the tests have a reference to the realtime
instance)

TODO make sure that we're only passing what's necessary dependency-wise;
there might be some leftovers

TODO make sure that we document what you need to not hold a strong
reference to

TODO note that we can keep our own objects and the channel alive for as long as we want
given the public API, but then we're stuck after that — i.e. if keeping
the channel alive doesn't keep the connection alive (not sure if it
does) then there's not a whole lot we can do

TODO address the stuff we did internally (keeping a reference to the
public type)

TODO remove the "default implementation" stuff

TODO documentation

TODO note that there are no weak references inside the codebase at the
moment, if we need them we'll add them

explain that the public classes are boring and that they just pass
dependencies and map to public

note that we get away with not passing CoreSDK because it's actually
barely used (just for checking channel state so far)

it's nice to in general not have to worry whether various properties are
nil or not — that said, I guess the worry is that it's easier to
accidentally capture something strongly, we'll have to think about what
to do there

maybe conflating channel and plugin into a single type was a mistake,
because it'll get in the way whenever we want to do something
non-channel related

Asked Cursor to fix the tests for me — TODO check

TODO umm but how is this going to work when we need to send something
ove the channel? I feel like I've missed something important here? ah,
no — if you want to publish, then the public will give you the CoreSDK
that you need

Author: lawrence-forooghian

Sources/AblyLiveObjects/DefaultRealtimeObjects.swift

@@ -2,13 +2,12 @@ import Ably
 internal import AblyPlugin
 
 /// The class that provides the public API for interacting with LiveObjects, via the ``ARTRealtimeChannel/objects`` property.
-internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolDelegate {
+internal final class DefaultRealtimeObjects: Sendable, LiveMapObjectPoolDelegate {
     // Used for synchronizing access to all of this instance's mutable state. This is a temporary solution just to allow us to implement `Sendable`, and we'll revisit it in https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/3.
     private let mutex = NSLock()
 
     private nonisolated(unsafe) var mutableState: MutableState!
 
-    private let coreSDK: CoreSDK
     private let logger: AblyPlugin.Logger
 
     // These drive the testsOnly_* properties that expose the received ProtocolMessages to the test suite.
@@ -70,13 +69,12 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
         }
     }
 
-    internal init(coreSDK: CoreSDK, logger: AblyPlugin.Logger) {
-        self.coreSDK = coreSDK
+    internal init(logger: AblyPlugin.Logger) {
         self.logger = logger
         (receivedObjectProtocolMessages, receivedObjectProtocolMessagesContinuation) = AsyncStream.makeStream()
         (receivedObjectSyncProtocolMessages, receivedObjectSyncProtocolMessagesContinuation) = AsyncStream.makeStream()
         (waitingForSyncEvents, waitingForSyncEventsContinuation) = AsyncStream.makeStream()
-        mutableState = .init(objectsPool: .init(rootDelegate: self, rootCoreSDK: coreSDK, logger: logger))
+        mutableState = .init(objectsPool: .init(logger: logger))
     }
 
     // MARK: - LiveMapObjectPoolDelegate
@@ -89,7 +87,7 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
 
     // MARK: `RealtimeObjects` protocol
 
-    internal func getRoot() async throws(ARTErrorInfo) -> any LiveMap {
+    internal func getRoot(coreSDK: CoreSDK) async throws(ARTErrorInfo) -> DefaultLiveMap {
         // RTO1b: If the channel is in the DETACHED or FAILED state, the library should indicate an error with code 90001
         let currentChannelState = coreSDK.channelState
         if currentChannelState == .detached || currentChannelState == .failed {
@@ -159,8 +157,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
             mutableState.onChannelAttached(
                 hasObjects: hasObjects,
                 logger: logger,
-                mapDelegate: self,
-                coreSDK: coreSDK,
             )
         }
     }
@@ -176,8 +172,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
                 objectMessages: objectMessages,
                 logger: logger,
                 receivedObjectProtocolMessagesContinuation: receivedObjectProtocolMessagesContinuation,
-                mapDelegate: self,
-                coreSDK: coreSDK,
             )
         }
     }
@@ -194,25 +188,23 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
                 protocolMessageChannelSerial: protocolMessageChannelSerial,
                 logger: logger,
                 receivedObjectSyncProtocolMessagesContinuation: receivedObjectSyncProtocolMessagesContinuation,
-                mapDelegate: self,
-                coreSDK: coreSDK,
             )
         }
     }
 
     /// Creates a zero-value LiveObject in the object pool for this object ID.
     ///
     /// Intended as a way for tests to populate the object pool.
-    internal func testsOnly_createZeroValueLiveObject(forObjectID objectID: String, coreSDK: CoreSDK) -> ObjectsPool.Entry? {
+    internal func testsOnly_createZeroValueLiveObject(forObjectID objectID: String) -> ObjectsPool.Entry? {
         mutex.withLock {
-            mutableState.objectsPool.createZeroValueObject(forObjectID: objectID, mapDelegate: self, coreSDK: coreSDK, logger: logger)
+            mutableState.objectsPool.createZeroValueObject(forObjectID: objectID, logger: logger)
         }
     }
 
     // MARK: - Sending `OBJECT` ProtocolMessage
 
     // This is currently exposed so that we can try calling it from the tests in the early days of the SDK to check that we can send an OBJECT ProtocolMessage. We'll probably make it private later on.
-    internal func testsOnly_sendObject(objectMessages: [OutboundObjectMessage]) async throws(InternalError) {
+    internal func testsOnly_sendObject(objectMessages: [OutboundObjectMessage], coreSDK: CoreSDK) async throws(InternalError) {
         try await coreSDK.sendObject(objectMessages: objectMessages)
     }
 
@@ -241,8 +233,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
         internal mutating func onChannelAttached(
             hasObjects: Bool,
             logger: Logger,
-            mapDelegate: LiveMapObjectPoolDelegate,
-            coreSDK: CoreSDK,
         ) {
             logger.log("onChannelAttached(hasObjects: \(hasObjects)", level: .debug)
 
@@ -255,7 +245,7 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
 
             // RTO4b1, RTO4b2: Reset the ObjectsPool to have a single empty root object
             // TODO: this one is unclear (are we meant to replace the root or just clear its data?) https://github.com/ably/specification/pull/333/files#r2183493458
-            objectsPool = .init(rootDelegate: mapDelegate, rootCoreSDK: coreSDK, logger: logger)
+            objectsPool = .init(logger: logger)
 
             // I have, for now, not directly implemented the "perform the actions for object sync completion" of RTO4b4 since my implementation doesn't quite match the model given there; here you only have a SyncObjectsPool if you have an OBJECT_SYNC in progress, which you might not have upon receiving an ATTACHED. Instead I've just implemented what seem like the relevant side effects. Can revisit this if "the actions for object sync completion" get more complex.
 
@@ -270,8 +260,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
             protocolMessageChannelSerial: String?,
             logger: Logger,
             receivedObjectSyncProtocolMessagesContinuation: AsyncStream<[InboundObjectMessage]>.Continuation,
-            mapDelegate: LiveMapObjectPoolDelegate,
-            coreSDK: CoreSDK,
         ) {
             logger.log("handleObjectSyncProtocolMessage(objectMessages: \(objectMessages), protocolMessageChannelSerial: \(String(describing: protocolMessageChannelSerial)))", level: .debug)
 
@@ -326,8 +314,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
                 // RTO5c
                 objectsPool.applySyncObjectsPool(
                     completedSyncObjectsPool,
-                    mapDelegate: mapDelegate,
-                    coreSDK: coreSDK,
                     logger: logger,
                 )
 
@@ -338,8 +324,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
                         applyObjectProtocolMessageObjectMessage(
                             objectMessage,
                             logger: logger,
-                            mapDelegate: mapDelegate,
-                            coreSDK: coreSDK,
                         )
                     }
                 }
@@ -356,8 +340,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
             objectMessages: [InboundObjectMessage],
             logger: Logger,
             receivedObjectProtocolMessagesContinuation: AsyncStream<[InboundObjectMessage]>.Continuation,
-            mapDelegate: LiveMapObjectPoolDelegate,
-            coreSDK: CoreSDK,
         ) {
             receivedObjectProtocolMessagesContinuation.yield(objectMessages)
 
@@ -375,8 +357,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
                     applyObjectProtocolMessageObjectMessage(
                         objectMessage,
                         logger: logger,
-                        mapDelegate: mapDelegate,
-                        coreSDK: coreSDK,
                     )
                 }
             }
@@ -386,8 +366,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
         private mutating func applyObjectProtocolMessageObjectMessage(
             _ objectMessage: InboundObjectMessage,
             logger: Logger,
-            mapDelegate: LiveMapObjectPoolDelegate,
-            coreSDK: CoreSDK,
         ) {
             guard let operation = objectMessage.operation else {
                 // RTO9a1
@@ -402,8 +380,6 @@ internal final class DefaultRealtimeObjects: RealtimeObjects, LiveMapObjectPoolD
             } else {
                 guard let newEntry = objectsPool.createZeroValueObject(
                     forObjectID: operation.objectId,
-                    mapDelegate: mapDelegate,
-                    coreSDK: coreSDK,
                     logger: logger,
                 ) else {
                     logger.log("Unable to create zero-value object for \(operation.objectId) when processing OBJECT message; dropping", level: .warn)

Sources/AblyLiveObjects/Internal/CoreSDK.swift

@@ -12,29 +12,17 @@ internal protocol CoreSDK: AnyObject, Sendable {
 }
 
 internal final class DefaultCoreSDK: CoreSDK {
-    // We hold a weak reference to the channel so that `DefaultLiveObjects` can hold a strong reference to us without causing a strong reference cycle. We'll revisit this in https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/9.
-    private let weakChannel: WeakRef<AblyPlugin.RealtimeChannel>
+    private let channel: AblyPlugin.RealtimeChannel
     private let pluginAPI: PluginAPIProtocol
 
     internal init(
         channel: AblyPlugin.RealtimeChannel,
         pluginAPI: PluginAPIProtocol
     ) {
-        weakChannel = .init(referenced: channel)
+        self.channel = channel
         self.pluginAPI = pluginAPI
     }
 
-    // MARK: - Fetching channel
-
-    private var channel: AblyPlugin.RealtimeChannel {
-        guard let channel = weakChannel.referenced else {
-            // It's currently completely possible that the channel _does_ become deallocated during the usage of the LiveObjects SDK; in https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/9 we'll figure out how to prevent this.
-            preconditionFailure("Expected channel to not become deallocated during usage of LiveObjects SDK")
-        }
-
-        return channel
-    }
-
     // MARK: - CoreSDK conformance
 
     internal func sendObject(objectMessages: [OutboundObjectMessage]) async throws(InternalError) {

Sources/AblyLiveObjects/Internal/DefaultInternalPlugin.swift

@@ -17,18 +17,10 @@ internal final class DefaultInternalPlugin: NSObject, AblyPlugin.LiveObjectsInte
     /// The `pluginDataValue(forKey:channel:)` key that we use to store the value of the `ARTRealtimeChannel.objects` property.
     private static let pluginDataKey = "LiveObjects"
 
-    /// Retrieves the value that should be returned by `ARTRealtimeChannel.objects`.
-    ///
-    /// We expect this value to have been previously set by ``prepare(_:)``.
-    internal static func objectsProperty(for channel: ARTRealtimeChannel, pluginAPI: AblyPlugin.PluginAPIProtocol) -> DefaultRealtimeObjects {
-        let pluginChannel = pluginAPI.channel(forPublicRealtimeChannel: channel)
-        return realtimeObjects(for: pluginChannel, pluginAPI: pluginAPI)
-    }
-
     /// Retrieves the `RealtimeObjects` for this channel.
     ///
     /// We expect this value to have been previously set by ``prepare(_:)``.
-    private static func realtimeObjects(for channel: AblyPlugin.RealtimeChannel, pluginAPI: AblyPlugin.PluginAPIProtocol) -> DefaultRealtimeObjects {
+    internal static func realtimeObjects(for channel: AblyPlugin.RealtimeChannel, pluginAPI: AblyPlugin.PluginAPIProtocol) -> DefaultRealtimeObjects {
         guard let pluginData = pluginAPI.pluginDataValue(forKey: pluginDataKey, channel: channel) else {
             // InternalPlugin.prepare was not called
             fatalError("To access LiveObjects functionality, you must pass the LiveObjects plugin in the client options when creating the ARTRealtime instance: `clientOptions.plugins = [.liveObjects: AblyLiveObjects.Plugin.self]`")
@@ -45,8 +37,7 @@ internal final class DefaultInternalPlugin: NSObject, AblyPlugin.LiveObjectsInte
         let logger = pluginAPI.logger(for: channel)
 
         logger.log("LiveObjects.DefaultInternalPlugin received prepare(_:)", level: .debug)
-        let coreSDK = DefaultCoreSDK(channel: channel, pluginAPI: pluginAPI)
-        let liveObjects = DefaultRealtimeObjects(coreSDK: coreSDK, logger: logger)
+        let liveObjects = DefaultRealtimeObjects(logger: logger)
         pluginAPI.setPluginDataValue(liveObjects, forKey: Self.pluginDataKey, channel: channel)
     }
 

Sources/AblyLiveObjects/Internal/DefaultLiveCounter.swift

@@ -3,7 +3,7 @@ internal import AblyPlugin
 import Foundation
 
 /// Our default implementation of ``LiveCounter``.
-internal final class DefaultLiveCounter: LiveCounter {
+internal final class DefaultLiveCounter: Sendable {
     // Used for synchronizing access to all of this instance's mutable state. This is a temporary solution just to allow us to implement `Sendable`, and we'll revisit it in https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/3.
     private let mutex = NSLock()
 
@@ -27,28 +27,24 @@ internal final class DefaultLiveCounter: LiveCounter {
         }
     }
 
-    private let coreSDK: CoreSDK
     private let logger: AblyPlugin.Logger
 
     // MARK: - Initialization
 
     internal convenience init(
         testsOnly_data data: Double,
         objectID: String,
-        coreSDK: CoreSDK,
         logger: AblyPlugin.Logger
     ) {
-        self.init(data: data, objectID: objectID, coreSDK: coreSDK, logger: logger)
+        self.init(data: data, objectID: objectID, logger: logger)
     }
 
     private init(
         data: Double,
         objectID: String,
-        coreSDK: CoreSDK,
         logger: AblyPlugin.Logger
     ) {
         mutableState = .init(liveObject: .init(objectID: objectID), data: data)
-        self.coreSDK = coreSDK
         self.logger = logger
     }
 
@@ -58,35 +54,31 @@ internal final class DefaultLiveCounter: LiveCounter {
     ///   - objectID: The value for the "private objectId field" of RTO5c1b1a.
     internal static func createZeroValued(
         objectID: String,
-        coreSDK: CoreSDK,
         logger: AblyPlugin.Logger,
     ) -> Self {
         .init(
             data: 0,
             objectID: objectID,
-            coreSDK: coreSDK,
             logger: logger,
         )
     }
 
     // MARK: - LiveCounter conformance
 
-    internal var value: Double {
-        get throws(ARTErrorInfo) {
-            // RTLC5b: If the channel is in the DETACHED or FAILED state, the library should indicate an error with code 90001
-            let currentChannelState = coreSDK.channelState
-            if currentChannelState == .detached || currentChannelState == .failed {
-                throw LiveObjectsError.objectsOperationFailedInvalidChannelState(
-                    operationDescription: "LiveCounter.value",
-                    channelState: currentChannelState,
-                )
-                .toARTErrorInfo()
-            }
+    internal func value(coreSDK: CoreSDK) throws(ARTErrorInfo) -> Double {
+        // RTLC5b: If the channel is in the DETACHED or FAILED state, the library should indicate an error with code 90001
+        let currentChannelState = coreSDK.channelState
+        if currentChannelState == .detached || currentChannelState == .failed {
+            throw LiveObjectsError.objectsOperationFailedInvalidChannelState(
+                operationDescription: "LiveCounter.value",
+                channelState: currentChannelState,
+            )
+            .toARTErrorInfo()
+        }
 
-            return mutex.withLock {
-                // RTLC5c
-                mutableState.data
-            }
+        return mutex.withLock {
+            // RTLC5c
+            mutableState.data
         }
     }