Fix issue: push rules was not retrieved after a clear cache.

We now store push rules from the sync response

CHANGES.md

@@ -16,6 +16,7 @@ Bugfix:
  - Fix characters erased from the Search field when the result are coming (#545)
  - "No connection" banner was displayed by mistake
  - Leaving community (from another client) has no effect on RiotX (#497)
+ - Push rules was not retrieved after a clear cache
 
 Translations:
  -

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/di/MoshiProvider.kt

@@ -23,6 +23,7 @@ import im.vector.matrix.android.internal.network.parsing.UriMoshiAdapter
 import im.vector.matrix.android.internal.session.sync.model.UserAccountData
 import im.vector.matrix.android.internal.session.sync.model.UserAccountDataDirectMessages
 import im.vector.matrix.android.internal.session.sync.model.UserAccountDataFallback
+import im.vector.matrix.android.internal.session.sync.model.UserAccountDataPushRules
 
 
 object MoshiProvider {
@@ -31,6 +32,7 @@ object MoshiProvider {
             .add(UriMoshiAdapter())
             .add(RuntimeJsonAdapterFactory.of(UserAccountData::class.java, "type", UserAccountDataFallback::class.java)
                     .registerSubtype(UserAccountDataDirectMessages::class.java, UserAccountData.TYPE_DIRECT_MESSAGES)
+                    .registerSubtype(UserAccountDataPushRules::class.java, UserAccountData.TYPE_PUSH_RULES)
             )
             .add(RuntimeJsonAdapterFactory.of(MessageContent::class.java, "msgtype", MessageDefaultContent::class.java)
                     .registerSubtype(MessageTextContent::class.java, MessageType.MSGTYPE_TEXT)

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/pushers/GetPushRulesTask.kt

@@ -15,14 +15,9 @@
  */
 package im.vector.matrix.android.internal.session.pushers
 
-import com.zhuinden.monarchy.Monarchy
-import im.vector.matrix.android.api.pushrules.RuleSetKey
 import im.vector.matrix.android.api.pushrules.rest.GetPushRulesResponse
-import im.vector.matrix.android.internal.database.mapper.PushRulesMapper
-import im.vector.matrix.android.internal.database.model.PushRulesEntity
 import im.vector.matrix.android.internal.network.executeRequest
 import im.vector.matrix.android.internal.task.Task
-import im.vector.matrix.android.internal.util.awaitTransaction
 import javax.inject.Inject
 
 
@@ -30,52 +25,17 @@ internal interface GetPushRulesTask : Task<GetPushRulesTask.Params, Unit> {
     data class Params(val scope: String)
 }
 
+/**
+ * We keep this task, but it should not be used anymore, the push rules comes from the sync response
+ */
 internal class DefaultGetPushRulesTask @Inject constructor(private val pushRulesApi: PushRulesApi,
-                                                           private val monarchy: Monarchy) : GetPushRulesTask {
+                                                           private val savePushRulesTask: SavePushRulesTask) : GetPushRulesTask {
 
     override suspend fun execute(params: GetPushRulesTask.Params) {
         val response = executeRequest<GetPushRulesResponse> {
             apiCall = pushRulesApi.getAllRules()
         }
-        val scope = params.scope
-        monarchy.awaitTransaction { realm ->
-            //clear existings?
-            //TODO
-            realm.where(PushRulesEntity::class.java)
-                    .findAll()
-                    .deleteAllFromRealm()
 
-            val content = PushRulesEntity(scope).apply { kind = RuleSetKey.CONTENT }
-            response.global.content?.forEach { rule ->
-                content.pushRules.add(PushRulesMapper.map(rule))
-            }
-            realm.insertOrUpdate(content)
-
-            val override = PushRulesEntity(scope).apply { kind = RuleSetKey.OVERRIDE }
-            response.global.override?.forEach { rule ->
-                PushRulesMapper.map(rule).also {
-                    override.pushRules.add(it)
-                }
-            }
-            realm.insertOrUpdate(override)
-
-            val rooms = PushRulesEntity(scope).apply { kind = RuleSetKey.ROOM }
-            response.global.room?.forEach { rule ->
-                rooms.pushRules.add(PushRulesMapper.map(rule))
-            }
-            realm.insertOrUpdate(rooms)
-
-            val senders = PushRulesEntity(scope).apply { kind = RuleSetKey.SENDER }
-            response.global.sender?.forEach { rule ->
-                senders.pushRules.add(PushRulesMapper.map(rule))
-            }
-            realm.insertOrUpdate(senders)
-
-            val underrides = PushRulesEntity(scope).apply { kind = RuleSetKey.UNDERRIDE }
-            response.global.underride?.forEach { rule ->
-                underrides.pushRules.add(PushRulesMapper.map(rule))
-            }
-            realm.insertOrUpdate(underrides)
-        }
+        savePushRulesTask.execute(SavePushRulesTask.Params(response))
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/pushers/PushersModule.kt

@@ -59,6 +59,9 @@ internal abstract class PushersModule {
     @Binds
     abstract fun bindGetPushRulesTask(getPushRulesTask: DefaultGetPushRulesTask): GetPushRulesTask
 
+    @Binds
+    abstract fun bindSavePushRulesTask(savePushRulesTask: DefaultSavePushRulesTask): SavePushRulesTask
+
     @Binds
     abstract fun bindRemovePusherTask(removePusherTask: DefaultRemovePusherTask): RemovePusherTask
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/pushers/SavePushRulesTask.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.matrix.android.internal.session.pushers
+
+import com.zhuinden.monarchy.Monarchy
+import im.vector.matrix.android.api.pushrules.RuleScope
+import im.vector.matrix.android.api.pushrules.RuleSetKey
+import im.vector.matrix.android.api.pushrules.rest.GetPushRulesResponse
+import im.vector.matrix.android.internal.database.mapper.PushRulesMapper
+import im.vector.matrix.android.internal.database.model.PushRulesEntity
+import im.vector.matrix.android.internal.task.Task
+import im.vector.matrix.android.internal.util.awaitTransaction
+import javax.inject.Inject
+
+
+/**
+ * Save the push rules in DB
+ */
+internal interface SavePushRulesTask : Task<SavePushRulesTask.Params, Unit> {
+    data class Params(val pushRules: GetPushRulesResponse)
+}
+
+internal class DefaultSavePushRulesTask @Inject constructor(private val monarchy: Monarchy) : SavePushRulesTask {
+
+    override suspend fun execute(params: SavePushRulesTask.Params) {
+        monarchy.awaitTransaction { realm ->
+            //clear existings?
+            //TODO
+            realm.where(PushRulesEntity::class.java)
+                    .findAll()
+                    .deleteAllFromRealm()
+
+            // Save only global rules for the moment
+            val globalRules = params.pushRules.global
+
+            val content = PushRulesEntity(RuleScope.GLOBAL).apply { kind = RuleSetKey.CONTENT }
+            globalRules.content?.forEach { rule ->
+                content.pushRules.add(PushRulesMapper.map(rule))
+            }
+            realm.insertOrUpdate(content)
+
+            val override = PushRulesEntity(RuleScope.GLOBAL).apply { kind = RuleSetKey.OVERRIDE }
+            globalRules.override?.forEach { rule ->
+                PushRulesMapper.map(rule).also {
+                    override.pushRules.add(it)
+                }
+            }
+            realm.insertOrUpdate(override)
+
+            val rooms = PushRulesEntity(RuleScope.GLOBAL).apply { kind = RuleSetKey.ROOM }
+            globalRules.room?.forEach { rule ->
+                rooms.pushRules.add(PushRulesMapper.map(rule))
+            }
+            realm.insertOrUpdate(rooms)
+
+            val senders = PushRulesEntity(RuleScope.GLOBAL).apply { kind = RuleSetKey.SENDER }
+            globalRules.sender?.forEach { rule ->
+                senders.pushRules.add(PushRulesMapper.map(rule))
+            }
+            realm.insertOrUpdate(senders)
+
+            val underrides = PushRulesEntity(RuleScope.GLOBAL).apply { kind = RuleSetKey.UNDERRIDE }
+            globalRules.underride?.forEach { rule ->
+                underrides.pushRules.add(PushRulesMapper.map(rule))
+            }
+            realm.insertOrUpdate(underrides)
+        }
+    }
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncResponseHandler.kt

@@ -33,7 +33,7 @@ internal class SyncResponseHandler @Inject constructor(private val roomSyncHandl
                                                        private val cryptoService: DefaultCryptoService,
                                                        private val initialSyncProgressService: DefaultInitialSyncProgressService) {
 
-    fun handleResponse(syncResponse: SyncResponse, fromToken: String?, isCatchingUp: Boolean): Try<SyncResponse> {
+    suspend fun handleResponse(syncResponse: SyncResponse, fromToken: String?, isCatchingUp: Boolean): Try<SyncResponse> {
         return Try {
             val isInitialSync = fromToken == null
             Timber.v("Start handling sync, is InitialSync: $isInitialSync")

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/UserAccountDataSyncHandler.kt

@@ -24,9 +24,11 @@ import im.vector.matrix.android.internal.database.model.RoomSummaryEntity
 import im.vector.matrix.android.internal.database.query.getDirectRooms
 import im.vector.matrix.android.internal.database.query.where
 import im.vector.matrix.android.internal.di.UserId
+import im.vector.matrix.android.internal.session.pushers.SavePushRulesTask
 import im.vector.matrix.android.internal.session.room.membership.RoomMembers
 import im.vector.matrix.android.internal.session.sync.model.InvitedRoomSync
 import im.vector.matrix.android.internal.session.sync.model.UserAccountDataDirectMessages
+import im.vector.matrix.android.internal.session.sync.model.UserAccountDataPushRules
 import im.vector.matrix.android.internal.session.sync.model.UserAccountDataSync
 import im.vector.matrix.android.internal.session.user.accountdata.DirectChatsHelper
 import im.vector.matrix.android.internal.session.user.accountdata.UpdateUserAccountDataTask
@@ -41,12 +43,14 @@ internal class UserAccountDataSyncHandler @Inject constructor(private val monarc
                                                               private val userId: String,
                                                               private val directChatsHelper: DirectChatsHelper,
                                                               private val updateUserAccountDataTask: UpdateUserAccountDataTask,
+                                                              private val savePushRulesTask: SavePushRulesTask,
                                                               private val taskExecutor: TaskExecutor) {
 
-    fun handle(accountData: UserAccountDataSync?, invites: Map<String, InvitedRoomSync>?) {
+    suspend fun handle(accountData: UserAccountDataSync?, invites: Map<String, InvitedRoomSync>?) {
         accountData?.list?.forEach {
             when (it) {
                 is UserAccountDataDirectMessages -> handleDirectChatRooms(it)
+                is UserAccountDataPushRules      -> handlePushRules(it)
                 else                             -> return@forEach
             }
         }
@@ -55,6 +59,10 @@ internal class UserAccountDataSyncHandler @Inject constructor(private val monarc
         }
     }
 
+    private suspend fun handlePushRules(userAccountDataPushRules: UserAccountDataPushRules) {
+        savePushRulesTask.execute(SavePushRulesTask.Params(userAccountDataPushRules.content))
+    }
+
     private fun handleDirectChatRooms(directMessages: UserAccountDataDirectMessages) {
         monarchy.runTransactionSync { realm ->
             val oldDirectRooms = RoomSummaryEntity.getDirectRooms(realm)

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/UserAccountData.kt

@@ -23,5 +23,6 @@ internal interface UserAccountData {
         const val TYPE_DIRECT_MESSAGES = "m.direct"
         const val TYPE_PREVIEW_URLS = "org.matrix.preview_urls"
         const val TYPE_WIDGETS = "m.widgets"
+        const val TYPE_PUSH_RULES = "m.push_rules"
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/UserAccountDataPushRules.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * 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.
+ */
+
+package im.vector.matrix.android.internal.session.sync.model
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+import im.vector.matrix.android.api.pushrules.rest.GetPushRulesResponse
+
+@JsonClass(generateAdapter = true)
+internal data class UserAccountDataPushRules(
+        @Json(name = "content") val content: GetPushRulesResponse
+) : UserAccountData
+

vector/src/main/java/im/vector/riotx/core/extensions/Session.kt

@@ -33,10 +33,6 @@ fun Session.configureAndStart(pushRuleTriggerListener: PushRuleTriggerListener)
     refreshPushers()
     pushRuleTriggerListener.startWithSession(this)
 
-    // TODO After a clear cache, this is not done.
-    // TODO Push rule should be parsed from the sync
-    fetchPushRules()
-
     // TODO P1 From HomeActivity
     // @Inject lateinit var incomingVerificationRequestHandler: IncomingVerificationRequestHandler
     // @Inject lateinit var keyRequestHandler: KeyRequestHandler

vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsNotificationFragment.kt

@@ -122,7 +122,7 @@ class VectorSettingsNotificationPreferenceFragment : VectorSettingsBaseFragment(
                             object : MatrixCallback<Unit> {
 
                                 override fun onSuccess(data: Unit) {
-                                    pushRuleService.fetchPushRules()
+                                    // Push rules will be updated form the sync
                                 }
 
                                 override fun onFailure(failure: Throwable) {