튜토리얼: Kotlin용 Atlas Device Sync

모델에 새 속성 추가

이제 모든 것이 예상대로 작동하는지 확인했으므로 변경 사항을 추가할 수 있습니다. 이 튜토리얼에서는 우선 순위에 따라 항목을 필터링할 수 있도록 각 항목에 '우선 순위' 속성을 추가합니다. 우선 순위 속성은 PriorityLevel 열거형에 매핑되어 사용 가능한 값을 제한하고, 각 열거형의 서수를 우선 순위 정수에 대응하도록 하여 나중에 숫자 우선 순위 수준을 기준으로 쿼리할 수 있도록 합니다.

이렇게 하려면 다음 단계를 따라 진행합니다.

1. app/java/com.mongodb.app/domain 폴더에서 Item 클래스 파일을 엽니다.

2. PriorityLevel 열거형을 추가하여 사용 가능한 값을 제한합니다. 또한 Item 클래스에 priority 속성을 추가합니다. 이 속성은 기본 우선 순위를 3으로 설정하여 우선 순위가 낮은 할 일 항목임을 나타냅니다.

   domain/Item.kt

   // ... imports
      enum class PriorityLevel() {
         Severe, // priority 0
         High,   // priority 1
         Medium, // priority 2
         Low     // priority 3
      }
      class Item() : RealmObject {
         @PrimaryKey
         var _id: ObjectId = ObjectId.create()
         var isComplete: Boolean = false
         var summary: String = ""
         var owner_id: String = ""
         var priority: Int = PriorityLevel.Low.ordinal
         constructor(ownerId: String = "") : this() {
            owner_id = ownerId
         }
   // ... equals() and hashCode() functions
   }

새 항목 생성 시 우선 순위 설정하기

1. ui/tasks 폴더에서 AddItem.kt 파일을 엽니다. 이 파일은 사용자가 새 할 일 항목을 추가하기 위해 '+' 버튼을 클릭할 때 표시되는 UI의 구성 가능한 기능을 정의합니다.

2. 먼저 package com.mongodb.app 아래에 다음 가져오기를 추가합니다:

   ui/tasks/AddItem.kt

   import androidx.compose.foundation.layout.fillMaxWidth
   import androidx.compose.foundation.layout.padding
   import androidx.compose.material3.DropdownMenuItem
   import androidx.compose.material3.ExposedDropdownMenuBox
   import androidx.compose.ui.Modifier
   import androidx.compose.ui.unit.dp
   import com.mongodb.app.domain.PriorityLevel

3. 이제 구성 가능한 AddItemPrompt 함수에 드롭다운 필드를 추가하면 사용자가 PriorityLevel 열거형을 사용 가능한 값으로 사용하여 목록에서 우선 순위 수준을 선택할 수 있습니다.

   ui/tasks/AddItem.kt

   // ... imports
   @OptIn(ExperimentalMaterial3Api::class)
   @Composable
   fun AddItemPrompt(viewModel: AddItemViewModel) {
      AlertDialog(
         containerColor = Color.White,
         onDismissRequest = {
               viewModel.closeAddTaskDialog()
         },
         title = { Text(stringResource(R.string.add_item)) },
         text = {
               Column {
                  Text(stringResource(R.string.enter_item_name))
                  TextField(
                     colors = ExposedDropdownMenuDefaults.textFieldColors(containerColor = Color.White),
                     value = viewModel.taskSummary.value,
                     maxLines = 2,
                     onValueChange = {
                           viewModel.updateTaskSummary(it)
                     },
                     label = { Text(stringResource(R.string.item_summary)) }
                  )
                  val priorities = PriorityLevel.values()
                  ExposedDropdownMenuBox(
                     modifier = Modifier.padding(16.dp),
                     expanded = viewModel.expanded.value,
                     onExpandedChange = { viewModel.open() },
                  ) {
                     TextField(
                           readOnly = true,
                           value = viewModel.taskPriority.value.name,
                           onValueChange = {},
                           label = { Text(stringResource(R.string.item_priority)) },
                           trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = viewModel.expanded.value) },
                           colors = ExposedDropdownMenuDefaults.textFieldColors(),
                           modifier = Modifier
                              .fillMaxWidth()
                              .menuAnchor()
                     )
                     ExposedDropdownMenu(
                           expanded = viewModel.expanded.value,
                           onDismissRequest = { viewModel.close() }
                     ) {
                           priorities.forEach {
                              DropdownMenuItem(
                                 text = { Text(it.name) },
                                 onClick = {
                                       viewModel.updateTaskPriority(it)
                                       viewModel.close()
                                 }
                              )
                           }
                     }
                  }
               }
         },
         // ... buttons
      )
   }

   Android Studio는 몇 가지 오류를 식별합니다. 다음 단계에서 관련 기능을 추가하여 해당 문제를 해결합니다.

4. 다음으로, 드롭다운 필드 레이블을 문자열 리소스로 정의합니다. res/values/strings.xml 파일을 열고 'resource' 요소 마지막 부분 앞에 다음을 추가합니다.

   res/values/strings.xml

   <string name="item_priority">Item Priority</string>

5. 이제 presentation/tasks 폴더에서 AddItemViewModel.kt 파일을 엽니다. 여기서는 새로운 드롭다운 필드와 관련된 비즈니스 로직을 추가합니다.

   package com.mongodb.app 아래에 PriorityLevel 가져오기를 추가한 다음 드롭다운 내에서 상태 변경을 처리하는 데 필요한 변수와 함수를 AddItemViewModel 클래스에 추가합니다.

   presentation/tasks/AddItemViewModel.kt

      // ... imports
      import com.mongodb.app.domain.PriorityLevel
      // ... events
      class AddItemViewModel(
         private val repository: SyncRepository
      ) : ViewModel() {
         private val _addItemPopupVisible: MutableState<Boolean> = mutableStateOf(false)
         val addItemPopupVisible: State<Boolean>
            get() = _addItemPopupVisible
         private val _taskSummary: MutableState<String> = mutableStateOf("")
         val taskSummary: State<String>
            get() = _taskSummary
         private val _taskPriority: MutableState<PriorityLevel> = mutableStateOf(PriorityLevel.Low)
         val taskPriority: State<PriorityLevel>
            get() = _taskPriority
         private val _expanded: MutableState<Boolean> = mutableStateOf(false)
         val expanded: State<Boolean>
            get() = _expanded
         private val _addItemEvent: MutableSharedFlow<AddItemEvent> = MutableSharedFlow()
         val addItemEvent: Flow<AddItemEvent>
            get() = _addItemEvent
         fun openAddTaskDialog() {
            _addItemPopupVisible.value = true
         }
         fun closeAddTaskDialog() {
            cleanUpAndClose()
         }
         fun updateTaskSummary(taskSummary: String) {
            _taskSummary.value = taskSummary
         }
         fun updateTaskPriority(taskPriority: PriorityLevel) {
            _taskPriority.value = taskPriority
         }
         fun open() {
            _expanded.value = true
         }
         fun close() {
            _expanded.value = false
         }
         // addTask() and cleanUpAndClose() functions
      }

   이제 addTask() 및 cleanUpAndClose() 함수를 업데이트하여 새로운 taskPriority 매개 변수를 포함하고, 우선 순위 정보로 메시지를 업데이트하고, 항목 추가 보기가 닫히면 우선 순위 필드를 낮음으로 재설정합니다:

   fun addTask() {
      CoroutineScope(Dispatchers.IO).launch {
            runCatching {
               repository.addTask(taskSummary.value, taskPriority.value)
            }.onSuccess {
               withContext(Dispatchers.Main) {
                  _addItemEvent.emit(AddItemEvent.Info("Task '$taskSummary' with priority '$taskPriority' added successfully."))
               }
            }.onFailure {
               withContext(Dispatchers.Main) {
                  _addItemEvent.emit(AddItemEvent.Error("There was an error while adding the task '$taskSummary'", it))
               }
            }
            cleanUpAndClose()
      }
   }
   private fun cleanUpAndClose() {
      _taskSummary.value = ""
      _taskPriority.value = PriorityLevel.Low
      _addItemPopupVisible.value = false
   }

6. 마지막으로 data 폴더에서 SyncRepository.kt 파일을 열어 항목을 영역에 쓰는 addTask() 함수의 동일한 변경 사항을 반영합니다.

   먼저 package com.mongodb.app 아래에 PriorityLevel 가져오기를 추가한 다음 addTask() 함수를 업데이트하여 taskPriority를 매개 변수로 전달하고 priority 필드를 영역에 정수로 씁니다(열거형 서수 사용).

   data/SyncRepository.kt

   // ... imports
   import com.mongodb.app.domain.PriorityLevel
   interface SyncRepository {
      // ... Sync functions
      suspend fun addTask(taskSummary: String, taskPriority: PriorityLevel)
      // ... Sync functions
   }
   class RealmSyncRepository(
      onSyncError: (session: SyncSession, error: SyncException) -> Unit
   ) : SyncRepository {
      // ... variables and SyncConfiguration initializer
      // ... Sync functions
      override suspend fun addTask(taskSummary: String, taskPriority: PriorityLevel) {
         val task = Item().apply {
               owner_id = currentUser.id
               summary = taskSummary
               priority = taskPriority.ordinal
         }
         realm.write {
               copyToRealm(task)
         }
      }
      override suspend fun updateSubscriptions(subscriptionType: SubscriptionType) {
         realm.subscriptions.update {
               removeAll()
               val query = when (subscriptionType) {
                  SubscriptionType.MINE -> getQuery(realm, SubscriptionType.MINE)
                  SubscriptionType.ALL -> getQuery(realm, SubscriptionType.ALL)
               }
               add(query, subscriptionType.name)
         }
      }
      // ... additional Sync functions
   }
   class MockRepository : SyncRepository {
      override fun getTaskList(): Flow<ResultsChange<Item>> = flowOf()
      override suspend fun toggleIsComplete(task: Item) = Unit
      override suspend fun addTask(taskSummary: String, taskPriority: PriorityLevel) = Unit
      override suspend fun updateSubscriptions(subscriptionType: SubscriptionType) = Unit
      override suspend fun deleteTask(task: Item) = Unit
      override fun getActiveSubscriptionType(realm: Realm?): SubscriptionType = SubscriptionType.ALL
      override fun pauseSync() = Unit
      override fun resumeSync() = Unit
      override fun isTaskMine(task: Item): Boolean = task.owner_id == MOCK_OWNER_ID_MINE
      override fun close() = Unit
      // ... companion object
   }

실행 및 테스트

이 시점에서 애플리케이션을 다시 실행할 수 있습니다. 이 튜토리얼의 앞부분에서 생성한 계정을 사용하여 로그인합니다. 이전에 생성한 하나의 항목이 표시됩니다. 새 항목을 추가하면 이제 우선 순위를 설정할 수 있습니다. 우선 순위를 High로 선택하고 항목을 저장합니다.

이제 브라우저에서 Atlas 데이터 페이지로 다시 전환하고 Item 컬렉션을 새로 고침 하십시오. 그러면 priority 필드가 추가되고 1로 설정된 새 항목이 표시됩니다. 기존 항목에는 priority 필드가 없습니다.

구독 업데이트

app/java/com.mongodb.app/data 폴더 내에서 SyncRepository.kt 파일을 엽니다. 여기서 Flexible Sync 구독을 정의합니다. 구독은 사용자의 기기 및 계정과 동기화되는 문서를 정의합니다. getQuery() 함수를 찾습니다. 현재 두 개의 구독을 구독하고 있음을 알 수 있습니다.

• MINE: ownerId 속성이 인증된 사용자와 일치하는 모든 문서입니다.

• ALL: 모든 사용자의 모든 문서.

오직 높음(High) 또는 심각(Severe)으로 표시된 항목만 동기화하도록 MINE 구독을 업데이트하려고 합니다.

기억하시겠지만 priority 필드는 int 유형으로, 가장 높은 우선 순위('심각(Severe)')의 값은 0이고 가장 낮은 우선 순위('낮음(Low)')의 값은 3입니다. 정수와 우선 순위 속성을 직접 비교할 수 있습니다. 이렇게 하려면 여기에 표시된 것처럼 우선 순위가 PriorityLevel.High(또는 1)보다 낮거나 같은 문서를 포함하도록 RQL 진술(statement)을 업데이트합니다.

private fun getQuery(realm: Realm, subscriptionType: SubscriptionType): RealmQuery<Item> =
   when (subscriptionType) {
         SubscriptionType.MINE -> realm.query("owner_id == $0 AND priority <= ${PriorityLevel.High.ordinal}", currentUser.id)
         SubscriptionType.ALL -> realm.query()
   }

또한 앱을 열 때마다 구독 쿼리가 동기화할 문서를 다시 계산하도록 강제합니다.

이렇게 하려면 애플리케이션이 시작할 때 호출하는 SyncConfiguration.Builder().initialSubscriptions() 함수를 찾습니다. 먼저 true로 설정한 reRunOnOpen 매개 변수를 추가한 다음 updateExisting을 true로 설정하여 기존 쿼리에 대한 업데이트를 허용합니다.

config = SyncConfiguration.Builder(currentUser, setOf(Item::class))
   .initialSubscriptions(rerunOnOpen = true) { realm ->
       // Subscribe to the active subscriptionType - first time defaults to MINE
       val activeSubscriptionType = getActiveSubscriptionType(realm)
       add(getQuery(realm, activeSubscriptionType), activeSubscriptionType.name, updateExisting = true)
   }
   .errorHandler { session: SyncSession, error: SyncException ->
       onSyncError.invoke(session, error)
   }
   .waitForInitialRemoteData()
   .build()

실행 및 테스트

애플리케이션을 다시 실행합니다. 이 튜토리얼의 앞부분에서 생성한 계정을 사용하여 로그인합니다.

Realm에서 문서 컬렉션을 다시 동기화하는 초기 시점 이후에는 사용자가 만든 새로운 High 우선 순위 항목을 볼 수 있습니다.

기능을 추가로 테스트하려면 다양한 우선 순위의 항목을 생성할 수 있습니다. 우선 순위가 높음보다 낮은 항목을 추가하려고 하면 권한이 없다는 알림 메시지가 표시됩니다.Logcat을 사용하여 로그를 확인하는 경우 항목이 '성공적으로 추가되었습니다'라는 메시지와 함께 동기화 오류가 표시됩니다.

ERROR "Client attempted a write that is outside of permissions or query
filters; it has been reverted"

이는 Realm이 항목을 로컬에서 생성하고 백엔드와 동기화한 다음 구독 규칙을 충족하지 않는다는 이유로 쓰기를 되돌렸기 때문입니다.

또한 처음에 생성한 문서의 우선순위가 null이므로 동기화되지 않습니다. 이 항목을 동기화하려면 Atlas UI에서 문서를 편집하고 우선 순위 필드에 값을 추가할 수 있습니다.