Sync android-sdk with js-sdk: Implement updates to v0.6.1 (#223)

* Add keepAlive option when detach a document

* Set Yorkie Server Url in gh-pages and publish CI/CD

Author: ntcong1997

.github/workflows/gh-pages.yml

@@ -15,6 +15,8 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: gradle
+      - name: Set Yorkie Server Url
+        run: echo YORKIE_SERVER_URL="https://api.yorkie.dev" > ./local.properties
       - run: ./gradlew dokkaHtml --no-configuration-cache
       - uses: JamesIves/[email protected]
         with:

.github/workflows/publish.yml

@@ -13,6 +13,8 @@ jobs:
           java-version: "17"
           distribution: "temurin"
           cache: gradle
+      - name: Set Yorkie Server Url
+        run: echo YORKIE_SERVER_URL="https://api.yorkie.dev" > ./local.properties
       - run: chmod +x gradlew
       - uses: gradle/gradle-build-action@v2
         with:

yorkie/src/main/kotlin/dev/yorkie/core/Client.kt

@@ -684,20 +684,24 @@ public class Client(
      * the changes should be applied to other replicas before GC time. For this,
      * if the [document] is no longer used by this [Client], it should be detached.
      */
-    public fun detachAsync(document: Document): Deferred<OperationResult> {
-        return scope.async {
-            checkYorkieError(
-                isActive,
-                YorkieException(ErrClientNotActivated, "client is not active"),
+    @OptIn(DelicateCoroutinesApi::class)
+    public fun detachAsync(
+        document: Document,
+        keepalive: Boolean = false,
+    ): Deferred<OperationResult> {
+        checkYorkieError(
+            isActive,
+            YorkieException(ErrClientNotActivated, "client is not active"),
+        )
+
+        val attachment = attachments.value[document.key]
+            ?: throw YorkieException(
+                ErrDocumentNotAttached,
+                "document(${document.key}) is not attached",
             )
 
+        val task = suspend suspend@{
             document.mutex.withLock {
-                val attachment = attachments.value[document.key]
-                    ?: throw YorkieException(
-                        ErrDocumentNotAttached,
-                        "document(${document.key}) is not attached",
-                    )
-
                 document.updateAsync { _, presence ->
                     presence.clear()
                 }.await()
@@ -711,14 +715,13 @@ public class Client(
                     request,
                     document.key.documentBasedRequestHeader,
                 ).getOrElse {
-                    ensureActive()
                     handleConnectException(it) { exception ->
                         if (errorCodeOf(exception) == ErrUnauthenticated.codeString) {
                             shouldRefreshToken = true
                         }
                         deactivateInternal()
                     }
-                    return@async Result.failure(it)
+                    return@suspend Result.failure(it)
                 }
                 val pack = response.changePack.toChangePack()
                 document.applyChangePack(pack)
@@ -729,6 +732,18 @@ public class Client(
             }
             SUCCESS
         }
+
+        return if (keepalive) {
+            GlobalScope.async(Dispatchers.IO) {
+                withContext(NonCancellable) {
+                    task()
+                }
+            }
+        } else {
+            scope.async {
+                task()
+            }
+        }
     }
 
     private fun detachInternal(document: Document) {

yorkie/src/test/kotlin/dev/yorkie/core/ClientTest.kt

@@ -23,6 +23,7 @@ import dev.yorkie.core.MockYorkieService.Companion.TEST_KEY
 import dev.yorkie.core.MockYorkieService.Companion.TEST_USER_ID
 import dev.yorkie.core.MockYorkieService.Companion.WATCH_SYNC_ERROR_DOCUMENT_KEY
 import dev.yorkie.document.Document
+import dev.yorkie.document.Document.DocStatus
 import dev.yorkie.document.Document.Event.StreamConnectionChanged
 import dev.yorkie.document.Document.Event.SyncStatusChanged
 import dev.yorkie.document.Document.Key
@@ -407,6 +408,47 @@ class ClientTest {
         }
     }
 
+    @Test
+    fun `detachAsync with keepalive true should work even after client close`() = runTest {
+        val service = spyk(MockYorkieService())
+        val client = Client(
+            options = Client.Options(
+                key = TEST_KEY,
+                apiKey = TEST_KEY,
+            ),
+            unaryClient = OkHttpClient(),
+            streamClient = OkHttpClient(),
+            dispatcher = createSingleThreadDispatcher("Client Test"),
+            host = "0.0.0.0",
+        )
+        client.service = service
+
+        val document = Document(Key(NORMAL_DOCUMENT_KEY))
+
+        // Activate and attach document
+        client.activateAsync().await()
+        client.attachAsync(document, syncMode = Manual).await()
+        assertEquals(DocStatus.Attached, document.status)
+
+        // Start detach with keepalive = true
+        val detachDeferred = async {
+            client.detachAsync(document, keepalive = true).await()
+        }
+
+        // Add a small delay to ensure the detach has started
+        delay(10)
+
+        // Close the client while detach might still be in progress
+        client.close()
+
+        // Wait for detach to complete
+        val result = detachDeferred.await()
+
+        // Verify that detach completed successfully despite client being closed
+        assertTrue(result.isSuccess)
+        assertEquals(DocStatus.Detached, document.status)
+    }
+
     private fun assertIsTestActorID(clientId: String) {
         assertEquals(TEST_ACTOR_ID, ActorID(clientId))
     }