チュートリアル: Atlas Device Sync for Kotlin

モデルへの新しいプロパティの追加

すべて期待どおりに動作していることが確認できたため、変更を追加できます。 このチュートリアルでは、各アイテムに「優先順位」プロパティを追加し、アイテムに優先順位をつけてフィルタリングできるようにしました。 優先順位プロパティをPriorityLevel列挙型にマッピングして、可能な値を制限します。各列挙型の序数を使用して優先順位整数に対応するようにします。これにより、後で数値優先レベルに基づいてクエリを実行できるようになります。

これを行うには、次の手順に従います。

1. app/java/com.mongodb.app/domainフォルダ内で、 Itemクラスファイルを開きます。

2. 可能な値を制限するには、 PriorityLevel列挙を追加します。 また、 Itemクラスにpriorityプロパティを追加します。これにより、デフォルトの優先順位が 3 に設定されます。これは、優先順位の低い Todo アイテムであることを示します。

   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ファイルを開きます。 このファイルは、ユーザーが [+] ボタンをクリックして新しい Todo 項目を追加するときに表示される 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にドロップダウン フィールドを追加します。

   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. 次に、ドロップダウン フィールド ラベルを string リソースとして定義します。 res/values/strings.xmlファイルを開き、「resource」要素を閉じる前に以下を追加します。

   res/values/strings.xl

   <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ファイルを開き、アイテムを Realm に書込むaddTask()関数で同じ変更を反映します。

   まず、 package com.mongodb.appの下にPriorityLevelインポートを追加し、 addTask()関数を更新してtaskPriorityをパラメーターとして渡し、 priorityフィールドを整数として Realm に書込みます（列挙序数を使用）。

   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
   }

およびテストの実行

この時点で、アプリケーションを再実行できます。 このチュートリアルの前半で作成したアカウントを使用してログインします。 過去に作成した 1 つのアイテムが表示されます。 新しいアイテムを追加すると、優先順位を設定できるようになります。 優先順位をHighに選択し、アイテムを保存します。

ブラウザで Atlas データページに切り替え、 Itemコレクションを更新します。 これでpriorityフィールドが追加され、 1に設定された新しいアイテムが表示されます。 既存のアイテムにはpriorityフィールドはありません。

クリックして拡大します

サブスクライブを更新する

app/java/com.mongodb.app/dataフォルダー内で、 SyncRepository.ktファイルを開き、Flexible Sync サブスクリプションを定義します。 サブスクリプションは、ユーザーのデバイスおよびアカウントと同期するドキュメントを定義します。 getQuery()関数を見つけます。 現在 2 つのサブスクライブをサブスクライブしていることがわかります。

• MINE: ownerIdプロパティが認証されたユーザーと一致するすべてのドキュメント。

• ALL: すべてのユーザーからのすべてのドキュメント。

MINEサブスクライブを更新して、優先度が「高」または「重要」とマークされたアイテムのみを同期するようにしたいと考えています。

ご存知のとおり、 priorityフィールドのタイプはintで、最高優先順位（"Severe"）の値は 0、最低優先順位（"Low"）の値は 3 です。次が可能です:整数と優先順位プロパティを直接比較します。 そのためには、次のように、優先順位が PerformanceLevel.High（または 1）より小さいドキュメントを含むように RQL ステートメントを編集します。

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()関数を見つけます。 まず、 reRunOnOpenパラメータ設定をtrueに追加し、次に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 がドキュメントコレクションを再同期する最初の瞬間、作成した優先順位の高い新しいアイテムが表示されます。

機能をさらにテストしたい場合は、さまざまな優先順位のアイテムを作成できます。 優先順位が「高」より低いアイテムを追加しようとすると、権限がないことを示す Toast メッセージが表示されます。 また、 Logcat を使用してログを 確認すると、 、アイテムが「正常に追加」されたことを示すメッセージと、その後に同期エラーが表示されます。

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

これは、このシナリオでは Realm はアイテムをローカルに作成し、バックエンドと同期した後、サブスクライブ ルールを満たしていないため書込みを元に戻すためです。

また、最初に作成したドキュメントは優先順位がnullになっているため、同期されないことにも注意してください。 このアイテムを同期する場合は、Atlas UI でドキュメントを編集し、優先順位フィールドに値を追加します。