Room now exposes methods to get the various Services

changelog.d/5858.sdk

@@ -0,0 +1 @@
+`Room` apis are now available by requesting the service first. For instance `Room.updateAvatar(...)` is now `Room.stateService().updateAvatar(...)`

matrix-sdk-android-flow/src/main/java/org/matrix/android/sdk/flow/FlowRoom.kt

@@ -21,6 +21,8 @@ import kotlinx.coroutines.flow.Flow
 import org.matrix.android.sdk.api.query.QueryStringValue
 import org.matrix.android.sdk.api.session.events.model.Event
 import org.matrix.android.sdk.api.session.room.Room
+import org.matrix.android.sdk.api.session.room.getStateEvent
+import org.matrix.android.sdk.api.session.room.getTimelineEvent
 import org.matrix.android.sdk.api.session.room.members.RoomMemberQueryParams
 import org.matrix.android.sdk.api.session.room.model.EventAnnotationsSummary
 import org.matrix.android.sdk.api.session.room.model.ReadReceipt
@@ -45,81 +47,81 @@ class FlowRoom(private val room: Room) {
     }
 
     fun liveRoomMembers(queryParams: RoomMemberQueryParams): Flow<List<RoomMemberSummary>> {
-        return room.getRoomMembersLive(queryParams).asFlow()
+        return room.membershipService().getRoomMembersLive(queryParams).asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getRoomMembers(queryParams)
+                    room.membershipService().getRoomMembers(queryParams)
                 }
     }
 
     fun liveAnnotationSummary(eventId: String): Flow<Optional<EventAnnotationsSummary>> {
-        return room.getEventAnnotationsSummaryLive(eventId).asFlow()
+        return room.relationService().getEventAnnotationsSummaryLive(eventId).asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getEventAnnotationsSummary(eventId).toOptional()
+                    room.relationService().getEventAnnotationsSummary(eventId).toOptional()
                 }
     }
 
     fun liveTimelineEvent(eventId: String): Flow<Optional<TimelineEvent>> {
-        return room.getTimelineEventLive(eventId).asFlow()
+        return room.timelineService().getTimelineEventLive(eventId).asFlow()
                 .startWith(room.coroutineDispatchers.io) {
                     room.getTimelineEvent(eventId).toOptional()
                 }
     }
 
     fun liveStateEvent(eventType: String, stateKey: QueryStringValue): Flow<Optional<Event>> {
-        return room.getStateEventLive(eventType, stateKey).asFlow()
+        return room.stateService().getStateEventLive(eventType, stateKey).asFlow()
                 .startWith(room.coroutineDispatchers.io) {
                     room.getStateEvent(eventType, stateKey).toOptional()
                 }
     }
 
     fun liveStateEvents(eventTypes: Set<String>): Flow<List<Event>> {
-        return room.getStateEventsLive(eventTypes).asFlow()
+        return room.stateService().getStateEventsLive(eventTypes).asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getStateEvents(eventTypes)
+                    room.stateService().getStateEvents(eventTypes)
                 }
     }
 
     fun liveReadMarker(): Flow<Optional<String>> {
-        return room.getReadMarkerLive().asFlow()
+        return room.readService().getReadMarkerLive().asFlow()
     }
 
     fun liveReadReceipt(): Flow<Optional<String>> {
-        return room.getMyReadReceiptLive().asFlow()
+        return room.readService().getMyReadReceiptLive().asFlow()
     }
 
     fun liveEventReadReceipts(eventId: String): Flow<List<ReadReceipt>> {
-        return room.getEventReadReceiptsLive(eventId).asFlow()
+        return room.readService().getEventReadReceiptsLive(eventId).asFlow()
     }
 
     fun liveDraft(): Flow<Optional<UserDraft>> {
-        return room.getDraftLive().asFlow()
+        return room.draftService().getDraftLive().asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getDraft().toOptional()
+                    room.draftService().getDraft().toOptional()
                 }
     }
 
     fun liveNotificationState(): Flow<RoomNotificationState> {
-        return room.getLiveRoomNotificationState().asFlow()
+        return room.roomPushRuleService().getLiveRoomNotificationState().asFlow()
     }
 
     fun liveThreadSummaries(): Flow<List<ThreadSummary>> {
-        return room.getAllThreadSummariesLive().asFlow()
+        return room.threadsService().getAllThreadSummariesLive().asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getAllThreadSummaries()
+                    room.threadsService().getAllThreadSummaries()
                 }
     }
 
     fun liveThreadList(): Flow<List<ThreadRootEvent>> {
-        return room.getAllThreadsLive().asFlow()
+        return room.threadsLocalService().getAllThreadsLive().asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getAllThreads()
+                    room.threadsLocalService().getAllThreads()
                 }
     }
 
     fun liveLocalUnreadThreadList(): Flow<List<ThreadRootEvent>> {
-        return room.getMarkedThreadNotificationsLive().asFlow()
+        return room.threadsLocalService().getMarkedThreadNotificationsLive().asFlow()
                 .startWith(room.coroutineDispatchers.io) {
-                    room.getMarkedThreadNotifications()
+                    room.threadsLocalService().getMarkedThreadNotifications()
                 }
     }
 }

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt

@@ -145,7 +145,7 @@ class CommonTestHelper(context: Context) {
      * @param nbOfMessages the number of time the message will be sent
      */
     fun sendTextMessage(room: Room, message: String, nbOfMessages: Int, timeout: Long = TestConstants.timeOutMillis): List<TimelineEvent> {
-        val timeline = room.createTimeline(null, TimelineSettings(10))
+        val timeline = room.timelineService().createTimeline(null, TimelineSettings(10))
         timeline.start()
         val sentEvents = sendTextMessagesBatched(timeline, room, message, nbOfMessages, timeout)
         timeline.dispose()
@@ -165,11 +165,11 @@ class CommonTestHelper(context: Context) {
                 .forEach { batchedMessages ->
                     batchedMessages.forEach { formattedMessage ->
                         if (rootThreadEventId != null) {
-                            room.replyInThread(
+                            room.relationService().replyInThread(
                                     rootThreadEventId = rootThreadEventId,
                                     replyInThreadText = formattedMessage)
                         } else {
-                            room.sendTextMessage(formattedMessage)
+                            room.sendService().sendTextMessage(formattedMessage)
                         }
                     }
                     waitWithLatch(timeout) { latch ->
@@ -214,7 +214,7 @@ class CommonTestHelper(context: Context) {
             numberOfMessages: Int,
             rootThreadEventId: String,
             timeout: Long = TestConstants.timeOutMillis): List<TimelineEvent> {
-        val timeline = room.createTimeline(null, TimelineSettings(10))
+        val timeline = room.timelineService().createTimeline(null, TimelineSettings(10))
         timeline.start()
         val sentEvents = sendTextMessagesBatched(timeline, room, message, numberOfMessages, timeout, rootThreadEventId)
         timeline.dispose()

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt

@@ -70,7 +70,7 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
         if (encryptedRoom) {
             testHelper.waitWithLatch { latch ->
                 val room = aliceSession.getRoom(roomId)!!
-                room.enableEncryption()
+                room.roomCryptoService().enableEncryption()
                 val roomSummaryLive = room.getRoomSummaryLive()
                 val roomSummaryObserver = object : Observer<Optional<RoomSummary>> {
                     override fun onChanged(roomSummary: Optional<RoomSummary>) {
@@ -109,14 +109,15 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
                 }
             }
             bobRoomSummariesLive.observeForever(newRoomObserver)
-            aliceRoom.invite(bobSession.myUserId)
+            aliceRoom.membershipService().invite(bobSession.myUserId)
         }
 
         testHelper.waitWithLatch { latch ->
             val bobRoomSummariesLive = bobSession.roomService().getRoomSummariesLive(roomSummaryQueryParams { })
             val roomJoinedObserver = object : Observer<List<RoomSummary>> {
                 override fun onChanged(t: List<RoomSummary>?) {
                     if (bobSession.getRoom(aliceRoomId)
+                                    ?.membershipService()
                                     ?.getRoomMember(bobSession.myUserId)
                                     ?.membership == Membership.JOIN) {
                         bobRoomSummariesLive.removeObserver(this)
@@ -161,7 +162,7 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
         val samSession = testHelper.createAccount(TestConstants.USER_SAM, defaultSessionParams)
 
         testHelper.runBlockingTest {
-            room.invite(samSession.myUserId, null)
+            room.membershipService().invite(samSession.myUserId, null)
         }
 
         testHelper.runBlockingTest {
@@ -261,6 +262,7 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
             val newRoomObserver = object : Observer<List<RoomSummary>> {
                 override fun onChanged(t: List<RoomSummary>?) {
                     if (bob.getRoom(roomId)
+                                    ?.membershipService()
                                     ?.getRoomMember(bob.myUserId)
                                     ?.membership == Membership.JOIN) {
                         bobRoomSummariesLive.removeObserver(this)
@@ -373,13 +375,13 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
         val room = aliceSession.getRoom(roomId)!!
 
         testHelper.runBlockingTest {
-            room.enableEncryption()
+            room.roomCryptoService().enableEncryption()
         }
 
         val sessions = mutableListOf(aliceSession)
         for (index in 1 until numberOfMembers) {
             val session = testHelper.createAccount("User_$index", defaultSessionParams)
-            testHelper.runBlockingTest(timeout = 600_000) { room.invite(session.myUserId, null) }
+            testHelper.runBlockingTest(timeout = 600_000) { room.membershipService().invite(session.myUserId, null) }
             println("TEST -> " + session.myUserId + " invited")
             testHelper.runBlockingTest { session.roomService().joinRoom(room.roomId, null, emptyList()) }
             println("TEST -> " + session.myUserId + " joined")

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/E2eeSanityTests.kt

@@ -42,6 +42,7 @@ import org.matrix.android.sdk.api.session.getRoom
 import org.matrix.android.sdk.api.session.getRoomSummary
 import org.matrix.android.sdk.api.session.room.Room
 import org.matrix.android.sdk.api.session.room.failure.JoinRoomFailure
+import org.matrix.android.sdk.api.session.room.getTimelineEvent
 import org.matrix.android.sdk.api.session.room.model.Membership
 import org.matrix.android.sdk.api.session.room.model.message.MessageContent
 import org.matrix.android.sdk.api.session.room.send.SendState
@@ -88,7 +89,7 @@ class E2eeSanityTests : InstrumentedTest {
         otherAccounts.forEach {
             testHelper.runBlockingTest {
                 Log.v("#E2E TEST", "Alice invites ${it.myUserId}")
-                aliceRoomPOV.invite(it.myUserId)
+                aliceRoomPOV.membershipService().invite(it.myUserId)
             }
         }
 
@@ -130,7 +131,7 @@ class E2eeSanityTests : InstrumentedTest {
         newAccount.forEach {
             testHelper.runBlockingTest {
                 Log.v("#E2E TEST", "Alice invites ${it.myUserId}")
-                aliceRoomPOV.invite(it.myUserId)
+                aliceRoomPOV.membershipService().invite(it.myUserId)
             }
         }
 
@@ -525,10 +526,10 @@ class E2eeSanityTests : InstrumentedTest {
     }
 
     private fun sendMessageInRoom(aliceRoomPOV: Room, text: String): String? {
-        aliceRoomPOV.sendTextMessage(text)
+        aliceRoomPOV.sendService().sendTextMessage(text)
         var sentEventId: String? = null
         testHelper.waitWithLatch(4 * TestConstants.timeOutMillis) { latch ->
-            val timeline = aliceRoomPOV.createTimeline(null, TimelineSettings(60))
+            val timeline = aliceRoomPOV.timelineService().createTimeline(null, TimelineSettings(60))
             timeline.start()
 
             testHelper.retryPeriodicallyWithLatch(latch) {

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/PreShareKeysTest.kt

@@ -30,6 +30,7 @@ import org.matrix.android.sdk.api.session.events.model.content.EncryptedEventCon
 import org.matrix.android.sdk.api.session.events.model.content.RoomKeyContent
 import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.api.session.getRoom
+import org.matrix.android.sdk.api.session.room.getTimelineEvent
 import org.matrix.android.sdk.common.CommonTestHelper
 import org.matrix.android.sdk.common.CryptoTestHelper
 

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/UnwedgingTest.kt

@@ -98,7 +98,7 @@ class UnwedgingTest : InstrumentedTest {
         val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
         val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
 
-        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(20))
+        val bobTimeline = roomFromBobPOV.timelineService().createTimeline(null, TimelineSettings(20))
         bobTimeline.start()
 
         val bobFinalLatch = CountDownLatch(1)
@@ -129,7 +129,7 @@ class UnwedgingTest : InstrumentedTest {
         messagesReceivedByBob = emptyList()
 
         // - Alice sends a 1st message with a 1st megolm session
-        roomFromAlicePOV.sendTextMessage("First message")
+        roomFromAlicePOV.sendService().sendTextMessage("First message")
 
         // Wait for the message to be received by Bob
         testHelper.await(latch)
@@ -157,7 +157,7 @@ class UnwedgingTest : InstrumentedTest {
 
         Timber.i("## CRYPTO | testUnwedging:  Alice sends a 2nd message with a 2nd megolm session")
         // - Alice sends a 2nd message with a 2nd megolm session
-        roomFromAlicePOV.sendTextMessage("Second message")
+        roomFromAlicePOV.sendService().sendTextMessage("Second message")
 
         // Wait for the message to be received by Bob
         testHelper.await(latch)
@@ -186,7 +186,7 @@ class UnwedgingTest : InstrumentedTest {
 
             Timber.i("## CRYPTO | testUnwedging: Alice sends a 3rd message with a 3rd megolm session but a wedged olm session")
             // - Alice sends a 3rd message with a 3rd megolm session but a wedged olm session
-            roomFromAlicePOV.sendTextMessage("Third message")
+            roomFromAlicePOV.sendService().sendTextMessage("Third message")
             // Bob should not be able to decrypt, because the session key could not be sent
         }
         bobTimeline.removeListener(bobEventsListener)

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/encryption/EncryptionTest.kt

@@ -49,7 +49,7 @@ class EncryptionTest : InstrumentedTest {
     fun test_EncryptionEvent() {
         performTest(roomShouldBeEncrypted = false) { room ->
             // Send an encryption Event as an Event (and not as a state event)
-            room.sendEvent(
+            room.sendService().sendEvent(
                     eventType = EventType.STATE_ROOM_ENCRYPTION,
                     content = EncryptionEventContent(algorithm = MXCRYPTO_ALGORITHM_MEGOLM).toContent()
             )
@@ -61,7 +61,7 @@ class EncryptionTest : InstrumentedTest {
         performTest(roomShouldBeEncrypted = true) { room ->
             runBlocking {
                 // Send an encryption Event as a State Event
-                room.sendStateEvent(
+                room.stateService().sendStateEvent(
                         eventType = EventType.STATE_ROOM_ENCRYPTION,
                         stateKey = "",
                         body = EncryptionEventContent(algorithm = MXCRYPTO_ALGORITHM_MEGOLM).toContent()
@@ -76,9 +76,9 @@ class EncryptionTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val room = aliceSession.getRoom(cryptoTestData.roomId)!!
 
-        room.isEncrypted() shouldBe false
+        room.roomCryptoService().isEncrypted() shouldBe false
 
-        val timeline = room.createTimeline(null, TimelineSettings(10))
+        val timeline = room.timelineService().createTimeline(null, TimelineSettings(10))
         val latch = CountDownLatch(1)
         val timelineListener = object : Timeline.Listener {
             override fun onTimelineFailure(throwable: Throwable) {
@@ -106,7 +106,7 @@ class EncryptionTest : InstrumentedTest {
         testHelper.await(latch)
         timeline.dispose()
         testHelper.waitWithLatch {
-            room.isEncrypted() shouldBe roomShouldBeEncrypted
+            room.roomCryptoService().isEncrypted() shouldBe roomShouldBeEncrypted
             it.countDown()
         }
         cryptoTestData.cleanUp(testHelper)

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt

@@ -51,6 +51,7 @@ import org.matrix.android.sdk.api.session.crypto.verification.VerificationTxStat
 import org.matrix.android.sdk.api.session.events.model.content.EncryptedEventContent
 import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.api.session.getRoom
+import org.matrix.android.sdk.api.session.room.getTimelineEvent
 import org.matrix.android.sdk.api.session.room.model.RoomDirectoryVisibility
 import org.matrix.android.sdk.api.session.room.model.create.CreateRoomParams
 import org.matrix.android.sdk.api.session.room.model.message.MessageContent
@@ -84,7 +85,7 @@ class KeyShareTests : InstrumentedTest {
         val room = aliceSession.getRoom(roomId)
         assertNotNull(room)
         Thread.sleep(4_000)
-        assertTrue(room?.isEncrypted() == true)
+        assertTrue(room?.roomCryptoService()?.isEncrypted() == true)
         val sentEventId = commonTestHelper.sendTextMessage(room!!, "My Message", 1).first().eventId
 
         // Open a new sessionx
@@ -351,7 +352,7 @@ class KeyShareTests : InstrumentedTest {
         val roomAlicePov = aliceSession.getRoom(roomId)
         assertNotNull(roomAlicePov)
         Thread.sleep(1_000)
-        assertTrue(roomAlicePov?.isEncrypted() == true)
+        assertTrue(roomAlicePov?.roomCryptoService()?.isEncrypted() == true)
         val secondEventId = commonTestHelper.sendTextMessage(roomAlicePov!!, "Message", 3)[1].eventId
 
         // Create bob session
@@ -375,7 +376,7 @@ class KeyShareTests : InstrumentedTest {
 
         // Let alice invite bob
         commonTestHelper.runBlockingTest {
-            roomAlicePov.invite(bobSession.myUserId, null)
+            roomAlicePov.membershipService().invite(bobSession.myUserId, null)
         }
 
         commonTestHelper.runBlockingTest {

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/WithHeldTests.kt

@@ -34,6 +34,7 @@ import org.matrix.android.sdk.api.session.events.model.content.EncryptedEventCon
 import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
 import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.api.session.getRoom
+import org.matrix.android.sdk.api.session.room.getTimelineEvent
 import org.matrix.android.sdk.common.CommonTestHelper
 import org.matrix.android.sdk.common.CryptoTestHelper
 import org.matrix.android.sdk.common.MockOkHttpInterceptor