Add RealtimeSyncOff and refactor interface of SyncMode

Examples/KanbanApp/KanbanApp/Kanban/KanbanViewModel.swift

@@ -37,8 +37,7 @@ class KanbanViewModel: ObservableObject {
     private let document: Document
 
     init() {
-        self.client = Client(rpcAddress: RPCAddress(host: "localhost", port: 8080),
-                             options: ClientOptions())
+        self.client = Client(RPCAddress(host: "localhost", port: 8080))
 
         let docKey = "KanbanViewModel-8"
         self.document = Document(key: docKey)

Examples/TextEditorApp/TextEditorApp/TextEditor/TextViewModel.swift

@@ -34,8 +34,7 @@ class TextViewModel {
         self.operationSubject = operationSubject
 
         // create client with RPCAddress.
-        self.client = Client(rpcAddress: RPCAddress(host: "localhost", port: 8080),
-                             options: ClientOptions())
+        self.client = Client(RPCAddress(host: "localhost", port: 8080))
 
         // create a document
         self.document = Document(key: "codemirror")
@@ -141,12 +140,12 @@ class TextViewModel {
         }
     }
 
-    func pause() async {
-        try? await self.client.pauseRemoteChanges(self.document)
+    func pause() async throws {
+        try await self.client.changeSyncMode(self.document, .realtimePushOnly)
     }
 
-    func resume() async {
-        try? await self.client.resumeRemoteChanges(self.document)
+    func resume() async throws {
+        try await self.client.changeSyncMode(self.document, .realtime)
     }
 
     private func decodePresence<T: Decodable>(_ dictionary: Any?) -> T? {

Examples/TextEditorApp/TextEditorApp/TextEditor/View/TextEditorViewController.swift

@@ -46,10 +46,14 @@ class TextEditorViewController: UIViewController {
         didSet {
             if oldValue != self.isCompositioning {
                 Task {
-                    if self.isCompositioning {
-                        await self.model?.pause()
-                    } else {
-                        await self.model?.resume()
+                    do {
+                        if self.isCompositioning {
+                            try await self.model?.pause()
+                        } else {
+                            try await self.model?.resume()
+                        }
+                    } catch {
+                        assertionFailure()
                     }
                 }
             }

Sources/Core/Attachment.swift

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 The Yorkie Authors. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import GRPC
+
+class Attachment {
+    var doc: Document
+    var docID: String
+    var syncMode: SyncMode
+    var remoteChangeEventReceived: Bool
+    var remoteWatchStream: GRPCAsyncServerStreamingCall<WatchDocumentRequest, WatchDocumentResponse>?
+    var watchLoopReconnectTimer: Timer?
+
+    init(doc: Document, docID: String, syncMode: SyncMode, remoteChangeEventReceived: Bool, remoteWatchStream: GRPCAsyncServerStreamingCall<WatchDocumentRequest, WatchDocumentResponse>? = nil, watchLoopReconnectTimer: Timer? = nil) {
+        self.doc = doc
+        self.docID = docID
+        self.syncMode = syncMode
+        self.remoteChangeEventReceived = remoteChangeEventReceived
+        self.remoteWatchStream = remoteWatchStream
+        self.watchLoopReconnectTimer = watchLoopReconnectTimer
+    }
+
+    /**
+     * `needRealtimeSync` returns whether the document needs to be synced in real time.
+     */
+    func needRealtimeSync() async -> Bool {
+        if self.syncMode == .realtimeSyncOff {
+            return false
+        }
+
+        let hasLocalChanges = await doc.hasLocalChanges()
+
+        return self.syncMode != .manual && (hasLocalChanges || self.remoteChangeEventReceived)
+    }
+}