{
- return mapOf("key" to value)
+ return rawMap.filter {
+ it.key != "signatures" && it.key != "unsigned"
+ }
}
/**
@@ -82,6 +90,7 @@ data class MXKey(
*
* "signed_curve25519:AAAAFw": {
* "key": "IjwIcskng7YjYcn0tS8TUOT2OHHtBSfMpcfIczCgXj4",
+ * "fallback" : true|false
* "signatures": {
* "@userId:matrix.org": {
* "ed25519:GMJRREOASV": "EUjp6pXzK9u3SDFR\/qLbzpOi3bEREeI6qMnKzXu992HsfuDDZftfJfiUXv9b\/Hqq1og4qM\/vCQJGTHAWMmgkCg"
@@ -107,7 +116,8 @@ data class MXKey(
type = components[0],
keyId = components[1],
value = params["key"] as String,
- signatures = params["signatures"] as Map>
+ signatures = params["signatures"] as Map>,
+ rawMap = params
)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/DbQualifiers.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/DbQualifiers.kt
index 49e155add8..8b78cd0d42 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/DbQualifiers.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/DbQualifiers.kt
@@ -37,3 +37,7 @@ internal annotation class CryptoDatabase
@Qualifier
@Retention(AnnotationRetention.RUNTIME)
internal annotation class IdentityDatabase
+
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class ContentScannerDatabase
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/network/NetworkConstants.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/network/NetworkConstants.kt
index 361a306d4f..1ab1042129 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/network/NetworkConstants.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/network/NetworkConstants.kt
@@ -38,6 +38,9 @@ internal object NetworkConstants {
// Integration
const val URI_INTEGRATION_MANAGER_PATH = "_matrix/integrations/v1/"
+ // Content scanner
+ const val URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE = "_matrix/media_proxy/unstable/"
+
// Federation
const val URI_FEDERATION_PATH = "_matrix/federation/v1/"
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultFileService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultFileService.kt
index 46c5967876..14dfc097cf 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultFileService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultFileService.kt
@@ -23,8 +23,10 @@ import androidx.core.content.FileProvider
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.completeWith
import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
import org.matrix.android.sdk.api.failure.Failure
import org.matrix.android.sdk.api.session.content.ContentUrlResolver
@@ -118,12 +120,24 @@ internal class DefaultFileService @Inject constructor(
val cachedFiles = getFiles(url, fileName, mimeType, elementToDecrypt != null)
if (!cachedFiles.file.exists()) {
- val resolvedUrl = contentUrlResolver.resolveFullSize(url) ?: throw IllegalArgumentException("url is null")
+ val resolvedUrl = contentUrlResolver.resolveForDownload(url, elementToDecrypt) ?: throw IllegalArgumentException("url is null")
- val request = Request.Builder()
- .url(resolvedUrl)
- .header(DOWNLOAD_PROGRESS_INTERCEPTOR_HEADER, url)
- .build()
+ val request = when (resolvedUrl) {
+ is ContentUrlResolver.ResolvedMethod.GET -> {
+ Request.Builder()
+ .url(resolvedUrl.url)
+ .header(DOWNLOAD_PROGRESS_INTERCEPTOR_HEADER, url)
+ .build()
+ }
+
+ is ContentUrlResolver.ResolvedMethod.POST -> {
+ Request.Builder()
+ .url(resolvedUrl.url)
+ .header(DOWNLOAD_PROGRESS_INTERCEPTOR_HEADER, url)
+ .post(resolvedUrl.jsonBody.toRequestBody("application/json".toMediaType()))
+ .build()
+ }
+ }
val response = try {
okHttpClient.newCall(request).execute()
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
index c52462612a..c07ff48cf4 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
@@ -35,6 +35,7 @@ import org.matrix.android.sdk.api.session.cache.CacheService
import org.matrix.android.sdk.api.session.call.CallSignalingService
import org.matrix.android.sdk.api.session.content.ContentUploadStateTracker
import org.matrix.android.sdk.api.session.content.ContentUrlResolver
+import org.matrix.android.sdk.api.session.contentscanner.ContentScannerService
import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.events.EventService
import org.matrix.android.sdk.api.session.file.ContentDownloadStateTracker
@@ -124,6 +125,7 @@ internal class DefaultSession @Inject constructor(
private val _sharedSecretStorageService: Lazy,
private val accountService: Lazy,
private val eventService: Lazy,
+ private val contentScannerService: Lazy,
private val identityService: IdentityService,
private val integrationManagerService: IntegrationManagerService,
private val thirdPartyService: Lazy,
@@ -174,8 +176,8 @@ internal class DefaultSession @Inject constructor(
lifecycleObservers.forEach {
it.onSessionStarted(this)
}
- sessionListeners.dispatch { _, listener ->
- listener.onSessionStarted(this)
+ dispatchTo(sessionListeners) { session, listener ->
+ listener.onSessionStarted(session)
}
}
}
@@ -217,8 +219,8 @@ internal class DefaultSession @Inject constructor(
// timelineEventDecryptor.destroy()
uiHandler.post {
lifecycleObservers.forEach { it.onSessionStopped(this) }
- sessionListeners.dispatch { _, listener ->
- listener.onSessionStopped(this)
+ dispatchTo(sessionListeners) { session, listener ->
+ listener.onSessionStopped(session)
}
}
cryptoService.get().close()
@@ -249,8 +251,8 @@ internal class DefaultSession @Inject constructor(
lifecycleObservers.forEach {
it.onClearCache(this)
}
- sessionListeners.dispatch { _, listener ->
- listener.onClearCache(this)
+ dispatchTo(sessionListeners) { session, listener ->
+ listener.onClearCache(session)
}
}
withContext(NonCancellable) {
@@ -260,8 +262,8 @@ internal class DefaultSession @Inject constructor(
}
override fun onGlobalError(globalError: GlobalError) {
- sessionListeners.dispatch { _, listener ->
- listener.onGlobalError(this, globalError)
+ dispatchTo(sessionListeners) { session, listener ->
+ listener.onGlobalError(session, globalError)
}
}
@@ -275,6 +277,8 @@ internal class DefaultSession @Inject constructor(
override fun cryptoService(): CryptoService = cryptoService.get()
+ override fun contentScannerService(): ContentScannerService = contentScannerService.get()
+
override fun identityService() = identityService
override fun fileService(): FileService = defaultFileService.get()
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
index bc8a707530..76e5d84e56 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
@@ -36,6 +36,7 @@ import org.matrix.android.sdk.internal.session.cache.CacheModule
import org.matrix.android.sdk.internal.session.call.CallModule
import org.matrix.android.sdk.internal.session.content.ContentModule
import org.matrix.android.sdk.internal.session.content.UploadContentWorker
+import org.matrix.android.sdk.internal.session.contentscanner.ContentScannerModule
import org.matrix.android.sdk.internal.session.filter.FilterModule
import org.matrix.android.sdk.internal.session.group.GetGroupDataWorker
import org.matrix.android.sdk.internal.session.group.GroupModule
@@ -94,6 +95,7 @@ import org.matrix.android.sdk.internal.util.system.SystemModule
AccountModule::class,
FederationModule::class,
CallModule::class,
+ ContentScannerModule::class,
SearchModule::class,
ThirdPartyModule::class,
SpaceModule::class,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionListeners.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionListeners.kt
index d5c661b1e4..756b9cef83 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionListeners.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionListeners.kt
@@ -18,15 +18,11 @@ package org.matrix.android.sdk.internal.session
import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.session.Session
-import org.matrix.android.sdk.internal.SessionManager
-import org.matrix.android.sdk.internal.di.SessionId
import timber.log.Timber
import javax.inject.Inject
@SessionScope
-internal class SessionListeners @Inject constructor(
- @SessionId private val sessionId: String,
- private val sessionManager: SessionManager) {
+internal class SessionListeners @Inject constructor() {
private val listeners = mutableSetOf()
@@ -42,18 +38,19 @@ internal class SessionListeners @Inject constructor(
}
}
- fun dispatch(block: (Session, Session.Listener) -> Unit) {
+ fun dispatch(session: Session, block: (Session, Session.Listener) -> Unit) {
synchronized(listeners) {
- val session = getSession() ?: return Unit.also {
- Timber.w("You don't have any attached session")
- }
listeners.forEach {
tryOrNull { block(session, it) }
}
}
}
-
- private fun getSession(): Session? {
- return sessionManager.getSessionComponent(sessionId)?.session()
- }
+}
+
+internal fun Session?.dispatchTo(sessionListeners: SessionListeners, block: (Session, Session.Listener) -> Unit) {
+ if (this == null) {
+ Timber.w("You don't have any attached session")
+ return
+ }
+ sessionListeners.dispatch(this, block)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/account/DeactivateAccountTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/account/DeactivateAccountTask.kt
index 1a8e80ab68..752856b931 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/account/DeactivateAccountTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/account/DeactivateAccountTask.kt
@@ -44,7 +44,7 @@ internal class DefaultDeactivateAccountTask @Inject constructor(
override suspend fun execute(params: DeactivateAccountTask.Params) {
val deactivateAccountParams = DeactivateAccountParams.create(params.userAuthParam, params.eraseAllData)
-
+ cleanupSession.stopActiveTasks()
val canCleanup = try {
executeRequest(globalErrorReceiver) {
accountAPI.deactivate(deactivateAccountParams)
@@ -71,7 +71,7 @@ internal class DefaultDeactivateAccountTask @Inject constructor(
runCatching { identityDisconnectTask.execute(Unit) }
.onFailure { Timber.w(it, "Unable to disconnect identity server") }
- cleanupSession.handle()
+ cleanupSession.cleanup()
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/cleanup/CleanupSession.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/cleanup/CleanupSession.kt
index e8d3eb1a78..c42141a0aa 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/cleanup/CleanupSession.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/cleanup/CleanupSession.kt
@@ -50,20 +50,26 @@ internal class CleanupSession @Inject constructor(
@CryptoDatabase private val realmCryptoConfiguration: RealmConfiguration,
@UserMd5 private val userMd5: String
) {
- suspend fun handle() {
+
+ fun stopActiveTasks() {
+ Timber.d("Cleanup: cancel pending works...")
+ workManagerProvider.cancelAllWorks()
+
+ Timber.d("Cleanup: stop session...")
+ sessionManager.stopSession(sessionId)
+ }
+
+ suspend fun cleanup() {
val sessionRealmCount = Realm.getGlobalInstanceCount(realmSessionConfiguration)
val cryptoRealmCount = Realm.getGlobalInstanceCount(realmCryptoConfiguration)
Timber.d("Realm instance ($sessionRealmCount - $cryptoRealmCount)")
- Timber.d("Cleanup: delete session params...")
- sessionParamsStore.delete(sessionId)
-
- Timber.d("Cleanup: cancel pending works...")
- workManagerProvider.cancelAllWorks()
-
Timber.d("Cleanup: release session...")
sessionManager.releaseSession(sessionId)
+ Timber.d("Cleanup: delete session params...")
+ sessionParamsStore.delete(sessionId)
+
Timber.d("Cleanup: clear session data...")
clearSessionDataTask.execute(Unit)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/content/DefaultContentUrlResolver.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/content/DefaultContentUrlResolver.kt
index 5c8cf99dc6..660ab8726f 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/content/DefaultContentUrlResolver.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/content/DefaultContentUrlResolver.kt
@@ -16,20 +16,45 @@
package org.matrix.android.sdk.internal.session.content
-import org.matrix.android.sdk.api.MatrixUrls
import org.matrix.android.sdk.api.MatrixUrls.isMxcUrl
+import org.matrix.android.sdk.api.MatrixUrls.removeMxcPrefix
import org.matrix.android.sdk.api.auth.data.HomeServerConnectionConfig
import org.matrix.android.sdk.api.session.content.ContentUrlResolver
+import org.matrix.android.sdk.api.session.contentscanner.ContentScannerService
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
import org.matrix.android.sdk.internal.network.NetworkConstants
+import org.matrix.android.sdk.internal.session.contentscanner.ScanEncryptorUtils
+import org.matrix.android.sdk.internal.session.contentscanner.model.toJson
import org.matrix.android.sdk.internal.util.ensureTrailingSlash
import javax.inject.Inject
-internal class DefaultContentUrlResolver @Inject constructor(homeServerConnectionConfig: HomeServerConnectionConfig) : ContentUrlResolver {
+internal class DefaultContentUrlResolver @Inject constructor(
+ homeServerConnectionConfig: HomeServerConnectionConfig,
+ private val scannerService: ContentScannerService
+) : ContentUrlResolver {
private val baseUrl = homeServerConnectionConfig.homeServerUriBase.toString().ensureTrailingSlash()
override val uploadUrl = baseUrl + NetworkConstants.URI_API_MEDIA_PREFIX_PATH_R0 + "upload"
+ override fun resolveForDownload(contentUrl: String?, elementToDecrypt: ElementToDecrypt?): ContentUrlResolver.ResolvedMethod? {
+ return if (scannerService.isScannerEnabled() && elementToDecrypt != null) {
+ val baseUrl = scannerService.getContentScannerServer()
+ val sep = if (baseUrl?.endsWith("/") == true) "" else "/"
+
+ val url = baseUrl + sep + NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE + "download_encrypted"
+
+ ContentUrlResolver.ResolvedMethod.POST(
+ url = url,
+ jsonBody = ScanEncryptorUtils
+ .getDownloadBodyAndEncryptIfNeeded(scannerService.serverPublicKey, contentUrl ?: "", elementToDecrypt)
+ .toJson()
+ )
+ } else {
+ resolveFullSize(contentUrl)?.let { ContentUrlResolver.ResolvedMethod.GET(it) }
+ }
+ }
+
override fun resolveFullSize(contentUrl: String?): String? {
return contentUrl
// do not allow non-mxc content URLs
@@ -37,7 +62,7 @@ internal class DefaultContentUrlResolver @Inject constructor(homeServerConnectio
?.let {
resolve(
contentUrl = it,
- prefix = NetworkConstants.URI_API_MEDIA_PREFIX_PATH_R0 + "download/"
+ toThumbnail = false
)
}
}
@@ -49,16 +74,27 @@ internal class DefaultContentUrlResolver @Inject constructor(homeServerConnectio
?.let {
resolve(
contentUrl = it,
- prefix = NetworkConstants.URI_API_MEDIA_PREFIX_PATH_R0 + "thumbnail/",
+ toThumbnail = true,
params = "?width=$width&height=$height&method=${method.value}"
)
}
}
private fun resolve(contentUrl: String,
- prefix: String,
- params: String = ""): String? {
- var serverAndMediaId = contentUrl.removePrefix(MatrixUrls.MATRIX_CONTENT_URI_SCHEME)
+ toThumbnail: Boolean,
+ params: String = ""): String {
+ var serverAndMediaId = contentUrl.removeMxcPrefix()
+
+ val apiPath = if (scannerService.isScannerEnabled()) {
+ NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE
+ } else {
+ NetworkConstants.URI_API_MEDIA_PREFIX_PATH_R0
+ }
+ val prefix = if (toThumbnail) {
+ apiPath + "thumbnail/"
+ } else {
+ apiPath + "download/"
+ }
val fragmentOffset = serverAndMediaId.indexOf("#")
var fragment = ""
if (fragmentOffset >= 0) {
@@ -66,6 +102,11 @@ internal class DefaultContentUrlResolver @Inject constructor(homeServerConnectio
serverAndMediaId = serverAndMediaId.substring(0, fragmentOffset)
}
- return baseUrl + prefix + serverAndMediaId + params + fragment
+ val resolvedUrl = if (scannerService.isScannerEnabled()) {
+ scannerService.getContentScannerServer()!!.ensureTrailingSlash()
+ } else {
+ baseUrl
+ }
+ return resolvedUrl + prefix + serverAndMediaId + params + fragment
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApi.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApi.kt
new file mode 100644
index 0000000000..46f1705806
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApi.kt
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import okhttp3.ResponseBody
+import org.matrix.android.sdk.internal.network.NetworkConstants
+import org.matrix.android.sdk.internal.session.contentscanner.model.DownloadBody
+import org.matrix.android.sdk.internal.session.contentscanner.model.ScanResponse
+import org.matrix.android.sdk.internal.session.contentscanner.model.ServerPublicKeyResponse
+import retrofit2.http.Body
+import retrofit2.http.GET
+import retrofit2.http.POST
+import retrofit2.http.Path
+
+/**
+ * https://github.com/matrix-org/matrix-content-scanner
+ */
+internal interface ContentScannerApi {
+
+ @POST(NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE + "download_encrypted")
+ suspend fun downloadEncrypted(@Body info: DownloadBody): ResponseBody
+
+ @POST(NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE + "scan_encrypted")
+ suspend fun scanFile(@Body info: DownloadBody): ScanResponse
+
+ @GET(NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE + "public_key")
+ suspend fun getServerPublicKey(): ServerPublicKeyResponse
+
+ @GET(NetworkConstants.URI_API_PREFIX_PATH_MEDIA_PROXY_UNSTABLE + "scan/{domain}/{mediaId}")
+ suspend fun scanMedia(@Path(value = "domain") domain: String, @Path(value = "mediaId") mediaId: String): ScanResponse
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApiProvider.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApiProvider.kt
new file mode 100644
index 0000000000..d8548bb238
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerApiProvider.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import org.matrix.android.sdk.internal.session.SessionScope
+import javax.inject.Inject
+
+@SessionScope
+internal class ContentScannerApiProvider @Inject constructor() {
+ var contentScannerApi: ContentScannerApi? = null
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerModule.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerModule.kt
new file mode 100644
index 0000000000..7ea74225cd
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ContentScannerModule.kt
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import dagger.Binds
+import dagger.Module
+import dagger.Provides
+import io.realm.RealmConfiguration
+import org.matrix.android.sdk.api.session.contentscanner.ContentScannerService
+import org.matrix.android.sdk.internal.database.RealmKeysUtils
+import org.matrix.android.sdk.internal.di.ContentScannerDatabase
+import org.matrix.android.sdk.internal.di.SessionFilesDirectory
+import org.matrix.android.sdk.internal.di.UserMd5
+import org.matrix.android.sdk.internal.session.SessionModule
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.session.contentscanner.data.ContentScannerStore
+import org.matrix.android.sdk.internal.session.contentscanner.db.ContentScannerRealmModule
+import org.matrix.android.sdk.internal.session.contentscanner.db.RealmContentScannerStore
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.DefaultDownloadEncryptedTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.DefaultGetServerPublicKeyTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.DefaultScanEncryptedTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.DefaultScanMediaTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.DownloadEncryptedTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.GetServerPublicKeyTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.ScanEncryptedTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.ScanMediaTask
+import java.io.File
+
+@Module
+internal abstract class ContentScannerModule {
+ @Module
+ companion object {
+
+ @JvmStatic
+ @Provides
+ @ContentScannerDatabase
+ @SessionScope
+ fun providesContentScannerRealmConfiguration(realmKeysUtils: RealmKeysUtils,
+ @SessionFilesDirectory directory: File,
+ @UserMd5 userMd5: String): RealmConfiguration {
+ return RealmConfiguration.Builder()
+ .directory(directory)
+ .name("matrix-sdk-content-scanning.realm")
+ .apply {
+ realmKeysUtils.configureEncryption(this, SessionModule.getKeyAlias(userMd5))
+ }
+ .allowWritesOnUiThread(true)
+ .modules(ContentScannerRealmModule())
+ .build()
+ }
+ }
+
+ @Binds
+ abstract fun bindContentScannerService(service: DisabledContentScannerService): ContentScannerService
+
+ @Binds
+ abstract fun bindContentScannerStore(store: RealmContentScannerStore): ContentScannerStore
+
+ @Binds
+ abstract fun bindDownloadEncryptedTask(task: DefaultDownloadEncryptedTask): DownloadEncryptedTask
+
+ @Binds
+ abstract fun bindGetServerPublicKeyTask(task: DefaultGetServerPublicKeyTask): GetServerPublicKeyTask
+
+ @Binds
+ abstract fun bindScanMediaTask(task: DefaultScanMediaTask): ScanMediaTask
+
+ @Binds
+ abstract fun bindScanEncryptedTask(task: DefaultScanEncryptedTask): ScanEncryptedTask
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DefaultContentScannerService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DefaultContentScannerService.kt
new file mode 100644
index 0000000000..4ecb337603
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DefaultContentScannerService.kt
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import androidx.lifecycle.LiveData
+import dagger.Lazy
+import kotlinx.coroutines.launch
+import okhttp3.OkHttpClient
+import org.matrix.android.sdk.api.session.contentscanner.ContentScannerService
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.api.session.contentscanner.ScanStatusInfo
+import org.matrix.android.sdk.api.util.Optional
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
+import org.matrix.android.sdk.internal.di.Unauthenticated
+import org.matrix.android.sdk.internal.network.RetrofitFactory
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.session.contentscanner.data.ContentScannerStore
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.GetServerPublicKeyTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.ScanEncryptedTask
+import org.matrix.android.sdk.internal.session.contentscanner.tasks.ScanMediaTask
+import org.matrix.android.sdk.internal.task.TaskExecutor
+import timber.log.Timber
+import javax.inject.Inject
+
+@SessionScope
+internal class DefaultContentScannerService @Inject constructor(
+ private val retrofitFactory: RetrofitFactory,
+ @Unauthenticated
+ private val okHttpClient: Lazy,
+ private val contentScannerApiProvider: ContentScannerApiProvider,
+ private val contentScannerStore: ContentScannerStore,
+ private val getServerPublicKeyTask: GetServerPublicKeyTask,
+ private val scanEncryptedTask: ScanEncryptedTask,
+ private val scanMediaTask: ScanMediaTask,
+ private val taskExecutor: TaskExecutor
+) : ContentScannerService {
+
+ // Cache public key in memory
+ override var serverPublicKey: String? = null
+ private set
+
+ override fun getContentScannerServer(): String? {
+ return contentScannerStore.getScannerUrl()
+ }
+
+ override suspend fun getServerPublicKey(forceDownload: Boolean): String? {
+ val api = contentScannerApiProvider.contentScannerApi ?: throw IllegalArgumentException("No content scanner define")
+
+ if (!forceDownload && serverPublicKey != null) {
+ return serverPublicKey
+ }
+
+ return getServerPublicKeyTask.execute(GetServerPublicKeyTask.Params(api)).also {
+ serverPublicKey = it
+ }
+ }
+
+ override suspend fun getScanResultForAttachment(mxcUrl: String, fileInfo: ElementToDecrypt?): ScanStatusInfo {
+ val result = if (fileInfo != null) {
+ scanEncryptedTask.execute(ScanEncryptedTask.Params(
+ mxcUrl = mxcUrl,
+ publicServerKey = getServerPublicKey(false),
+ encryptedInfo = fileInfo
+ ))
+ } else {
+ scanMediaTask.execute(ScanMediaTask.Params(mxcUrl))
+ }
+
+ return ScanStatusInfo(
+ state = if (result.clean) ScanState.TRUSTED else ScanState.INFECTED,
+ humanReadableMessage = result.info,
+ scanDateTimestamp = System.currentTimeMillis()
+ )
+ }
+
+ override fun setScannerUrl(url: String?) = contentScannerStore.setScannerUrl(url).also {
+ if (url == null) {
+ contentScannerApiProvider.contentScannerApi = null
+ serverPublicKey = null
+ } else {
+ val api = retrofitFactory
+ .create(okHttpClient, url)
+ .create(ContentScannerApi::class.java)
+ contentScannerApiProvider.contentScannerApi = api
+
+ taskExecutor.executorScope.launch {
+ try {
+ getServerPublicKey(true)
+ } catch (failure: Throwable) {
+ Timber.e("Failed to get public server api")
+ }
+ }
+ }
+ }
+
+ override fun enableScanner(enabled: Boolean) = contentScannerStore.enableScanner(enabled)
+
+ override fun isScannerEnabled(): Boolean = contentScannerStore.isScanEnabled()
+
+ override fun getCachedScanResultForFile(mxcUrl: String): ScanStatusInfo? {
+ return contentScannerStore.getScanResult(mxcUrl)
+ }
+
+ override fun getLiveStatusForFile(mxcUrl: String, fetchIfNeeded: Boolean, fileInfo: ElementToDecrypt?): LiveData> {
+ val data = contentScannerStore.getLiveScanResult(mxcUrl)
+ if (fetchIfNeeded && !contentScannerStore.isScanResultKnownOrInProgress(mxcUrl, getContentScannerServer())) {
+ taskExecutor.executorScope.launch {
+ try {
+ getScanResultForAttachment(mxcUrl, fileInfo)
+ } catch (failure: Throwable) {
+ Timber.e("Failed to get file status : ${failure.localizedMessage}")
+ }
+ }
+ }
+ return data
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DisabledContentScannerService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DisabledContentScannerService.kt
new file mode 100644
index 0000000000..9087c71566
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/DisabledContentScannerService.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import org.matrix.android.sdk.api.session.contentscanner.ContentScannerService
+import org.matrix.android.sdk.api.session.contentscanner.ScanStatusInfo
+import org.matrix.android.sdk.api.util.Optional
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
+import org.matrix.android.sdk.internal.session.SessionScope
+import javax.inject.Inject
+
+/**
+ * Created to by-pass ProfileTask execution in LoginWizard.
+ */
+@SessionScope
+internal class DisabledContentScannerService @Inject constructor() : ContentScannerService {
+
+ override val serverPublicKey: String?
+ get() = null
+
+ override fun getContentScannerServer(): String? {
+ return null
+ }
+
+ override suspend fun getServerPublicKey(forceDownload: Boolean): String? {
+ return null
+ }
+
+ override suspend fun getScanResultForAttachment(mxcUrl: String, fileInfo: ElementToDecrypt?): ScanStatusInfo {
+ TODO("Not yet implemented")
+ }
+
+ override fun setScannerUrl(url: String?) {
+ }
+
+ override fun enableScanner(enabled: Boolean) {
+ }
+
+ override fun isScannerEnabled(): Boolean {
+ return false
+ }
+
+ override fun getLiveStatusForFile(mxcUrl: String, fetchIfNeeded: Boolean, fileInfo: ElementToDecrypt?): LiveData> {
+ return MutableLiveData()
+ }
+
+ override fun getCachedScanResultForFile(mxcUrl: String): ScanStatusInfo? {
+ return null
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ScanEncryptorUtils.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ScanEncryptorUtils.kt
new file mode 100644
index 0000000000..8fc84a487e
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/ScanEncryptorUtils.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner
+
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
+import org.matrix.android.sdk.internal.crypto.model.rest.EncryptedFileInfo
+import org.matrix.android.sdk.internal.crypto.model.rest.EncryptedFileKey
+import org.matrix.android.sdk.internal.crypto.tools.withOlmEncryption
+import org.matrix.android.sdk.internal.session.contentscanner.model.DownloadBody
+import org.matrix.android.sdk.internal.session.contentscanner.model.EncryptedBody
+import org.matrix.android.sdk.internal.session.contentscanner.model.toCanonicalJson
+
+internal object ScanEncryptorUtils {
+
+ fun getDownloadBodyAndEncryptIfNeeded(publicServerKey: String?, mxcUrl: String, elementToDecrypt: ElementToDecrypt): DownloadBody {
+ // TODO, upstream refactoring changed the object model here...
+ // it's bad we have to recreate and use hardcoded values
+ val encryptedInfo = EncryptedFileInfo(
+ url = mxcUrl,
+ iv = elementToDecrypt.iv,
+ hashes = mapOf("sha256" to elementToDecrypt.sha256),
+ key = EncryptedFileKey(
+ k = elementToDecrypt.k,
+ alg = "A256CTR",
+ keyOps = listOf("encrypt", "decrypt"),
+ kty = "oct",
+ ext = true
+ ),
+ v = "v2"
+ )
+ return if (publicServerKey != null) {
+ // We should encrypt
+ withOlmEncryption { olm ->
+ olm.setRecipientKey(publicServerKey)
+
+ val olmResult = olm.encrypt(DownloadBody(encryptedInfo).toCanonicalJson())
+ DownloadBody(
+ encryptedBody = EncryptedBody(
+ cipherText = olmResult.mCipherText,
+ ephemeral = olmResult.mEphemeralKey,
+ mac = olmResult.mMac
+ )
+ )
+ }
+ } else {
+ DownloadBody(encryptedInfo)
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/data/ContentScannerStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/data/ContentScannerStore.kt
new file mode 100644
index 0000000000..5cfe851a5c
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/data/ContentScannerStore.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.data
+
+import androidx.lifecycle.LiveData
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.api.session.contentscanner.ScanStatusInfo
+import org.matrix.android.sdk.api.util.Optional
+
+internal interface ContentScannerStore {
+
+ fun getScannerUrl(): String?
+
+ fun setScannerUrl(url: String?)
+
+ fun enableScanner(enabled: Boolean)
+
+ fun isScanEnabled(): Boolean
+
+ fun getScanResult(mxcUrl: String): ScanStatusInfo?
+ fun getLiveScanResult(mxcUrl: String): LiveData>
+ fun isScanResultKnownOrInProgress(mxcUrl: String, scannerUrl: String?): Boolean
+
+ fun updateStateForContent(mxcUrl: String, state: ScanState, scannerUrl: String?)
+ fun updateScanResultForContent(mxcUrl: String, scannerUrl: String?, state: ScanState, humanReadable: String)
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScanResultEntity.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScanResultEntity.kt
new file mode 100644
index 0000000000..0ffff441f8
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScanResultEntity.kt
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.db
+
+import io.realm.RealmObject
+import io.realm.annotations.Index
+import org.matrix.android.sdk.api.extensions.tryOrNull
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.api.session.contentscanner.ScanStatusInfo
+
+internal open class ContentScanResultEntity(
+ @Index
+ var mediaUrl: String? = null,
+ var scanStatusString: String? = null,
+ var humanReadableMessage: String? = null,
+ var scanDateTimestamp: Long? = null,
+ var scannerUrl: String? = null
+) : RealmObject() {
+
+ var scanResult: ScanState
+ get() {
+ return scanStatusString
+ ?.let {
+ tryOrNull { ScanState.valueOf(it) }
+ }
+ ?: ScanState.UNKNOWN
+ }
+ set(result) {
+ scanStatusString = result.name
+ }
+
+ fun toModel(): ScanStatusInfo {
+ return ScanStatusInfo(
+ state = this.scanResult,
+ humanReadableMessage = humanReadableMessage,
+ scanDateTimestamp = scanDateTimestamp
+ )
+ }
+
+ companion object
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerEntityQueries.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerEntityQueries.kt
new file mode 100644
index 0000000000..b47be235c6
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerEntityQueries.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.db
+
+import io.realm.Realm
+import io.realm.kotlin.createObject
+import io.realm.kotlin.where
+
+internal fun ContentScanResultEntity.Companion.get(realm: Realm, attachmentUrl: String, contentScannerUrl: String?): ContentScanResultEntity? {
+ return realm.where()
+ .equalTo(ContentScanResultEntityFields.MEDIA_URL, attachmentUrl)
+ .apply {
+ contentScannerUrl?.let {
+ equalTo(ContentScanResultEntityFields.SCANNER_URL, it)
+ }
+ }
+ .findFirst()
+}
+
+internal fun ContentScanResultEntity.Companion.getOrCreate(realm: Realm, attachmentUrl: String, contentScannerUrl: String?): ContentScanResultEntity {
+ return ContentScanResultEntity.get(realm, attachmentUrl, contentScannerUrl)
+ ?: realm.createObject().also {
+ it.mediaUrl = attachmentUrl
+ it.scanDateTimestamp = System.currentTimeMillis()
+ it.scannerUrl = contentScannerUrl
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerInfoEntity.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerInfoEntity.kt
new file mode 100644
index 0000000000..d1910de36a
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerInfoEntity.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.db
+
+import io.realm.RealmObject
+
+internal open class ContentScannerInfoEntity(
+ var serverUrl: String? = null,
+ var enabled: Boolean? = null
+) : RealmObject() {
+
+ companion object
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerRealmModule.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerRealmModule.kt
new file mode 100644
index 0000000000..bb53140ad9
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/ContentScannerRealmModule.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.db
+
+import io.realm.annotations.RealmModule
+
+/**
+ * Realm module for content scanner classes
+ */
+@RealmModule(library = true,
+ classes = [
+ ContentScannerInfoEntity::class,
+ ContentScanResultEntity::class
+ ])
+internal class ContentScannerRealmModule
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/RealmContentScannerStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/RealmContentScannerStore.kt
new file mode 100644
index 0000000000..947a66c8b9
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/db/RealmContentScannerStore.kt
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.db
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.Transformations
+import com.zhuinden.monarchy.Monarchy
+import io.realm.Realm
+import io.realm.RealmConfiguration
+import io.realm.kotlin.createObject
+import io.realm.kotlin.where
+import org.matrix.android.sdk.api.extensions.orFalse
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.api.session.contentscanner.ScanStatusInfo
+import org.matrix.android.sdk.api.util.Optional
+import org.matrix.android.sdk.api.util.toOptional
+import org.matrix.android.sdk.internal.di.ContentScannerDatabase
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.session.contentscanner.data.ContentScannerStore
+import org.matrix.android.sdk.internal.util.isValidUrl
+import javax.inject.Inject
+
+@SessionScope
+internal class RealmContentScannerStore @Inject constructor(
+ @ContentScannerDatabase
+ private val realmConfiguration: RealmConfiguration
+) : ContentScannerStore {
+
+ private val monarchy = Monarchy.Builder()
+ .setRealmConfiguration(realmConfiguration)
+ .build()
+
+ override fun getScannerUrl(): String? {
+ return monarchy.fetchAllMappedSync(
+ { realm ->
+ realm.where()
+ }, {
+ it.serverUrl
+ }
+ ).firstOrNull()
+ }
+
+ override fun setScannerUrl(url: String?) {
+ monarchy.runTransactionSync { realm ->
+ val info = realm.where().findFirst()
+ ?: realm.createObject()
+ info.serverUrl = url
+ }
+ }
+
+ override fun enableScanner(enabled: Boolean) {
+ monarchy.runTransactionSync { realm ->
+ val info = realm.where().findFirst()
+ ?: realm.createObject()
+ info.enabled = enabled
+ }
+ }
+
+ override fun isScanEnabled(): Boolean {
+ return monarchy.fetchAllMappedSync(
+ { realm ->
+ realm.where()
+ }, {
+ it.enabled.orFalse() && it.serverUrl?.isValidUrl().orFalse()
+ }
+ ).firstOrNull().orFalse()
+ }
+
+ override fun updateStateForContent(mxcUrl: String, state: ScanState, scannerUrl: String?) {
+ monarchy.runTransactionSync {
+ ContentScanResultEntity.getOrCreate(it, mxcUrl, scannerUrl).scanResult = state
+ }
+ }
+
+ override fun updateScanResultForContent(mxcUrl: String, scannerUrl: String?, state: ScanState, humanReadable: String) {
+ monarchy.runTransactionSync {
+ ContentScanResultEntity.getOrCreate(it, mxcUrl, scannerUrl).apply {
+ scanResult = state
+ scanDateTimestamp = System.currentTimeMillis()
+ humanReadableMessage = humanReadable
+ }
+ }
+ }
+
+ override fun isScanResultKnownOrInProgress(mxcUrl: String, scannerUrl: String?): Boolean {
+ var isKnown = false
+ monarchy.runTransactionSync {
+ val info = ContentScanResultEntity.get(it, mxcUrl, scannerUrl)?.scanResult
+ isKnown = when (info) {
+ ScanState.IN_PROGRESS,
+ ScanState.TRUSTED,
+ ScanState.INFECTED -> true
+ else -> false
+ }
+ }
+ return isKnown
+ }
+
+ override fun getScanResult(mxcUrl: String): ScanStatusInfo? {
+ return monarchy.fetchAllMappedSync({ realm ->
+ realm.where()
+ .equalTo(ContentScanResultEntityFields.MEDIA_URL, mxcUrl)
+ .apply {
+ getScannerUrl()?.let {
+ equalTo(ContentScanResultEntityFields.SCANNER_URL, it)
+ }
+ }
+ }, {
+ it.toModel()
+ })
+ .firstOrNull()
+ }
+
+ override fun getLiveScanResult(mxcUrl: String): LiveData> {
+ val liveData = monarchy.findAllMappedWithChanges(
+ { realm: Realm ->
+ realm.where()
+ .equalTo(ContentScanResultEntityFields.MEDIA_URL, mxcUrl)
+ .equalTo(ContentScanResultEntityFields.SCANNER_URL, getScannerUrl())
+ },
+ { entity ->
+ entity.toModel()
+ }
+ )
+ return Transformations.map(liveData) {
+ it.firstOrNull().toOptional()
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/DownloadBody.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/DownloadBody.kt
new file mode 100644
index 0000000000..5bac96a0c0
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/DownloadBody.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.model
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+import org.matrix.android.sdk.internal.crypto.model.rest.EncryptedFileInfo
+import org.matrix.android.sdk.internal.di.MoshiProvider
+import org.matrix.android.sdk.internal.util.JsonCanonicalizer
+
+@JsonClass(generateAdapter = true)
+internal data class DownloadBody(
+ @Json(name = "file") val file: EncryptedFileInfo? = null,
+ @Json(name = "encrypted_body") val encryptedBody: EncryptedBody? = null
+)
+
+@JsonClass(generateAdapter = true)
+internal data class EncryptedBody(
+ @Json(name = "ciphertext") val cipherText: String,
+ @Json(name = "mac") val mac: String,
+ @Json(name = "ephemeral") val ephemeral: String
+)
+
+internal fun DownloadBody.toJson(): String = MoshiProvider.providesMoshi().adapter(DownloadBody::class.java).toJson(this)
+
+internal fun DownloadBody.toCanonicalJson() = JsonCanonicalizer.getCanonicalJson(DownloadBody::class.java, this)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ScanResponse.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ScanResponse.kt
new file mode 100644
index 0000000000..f783fe0a6c
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ScanResponse.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.model
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * {
+ * "clean": true,
+ * "info": "File clean at 6/7/2018, 6:02:40 PM"
+ * }
+ */
+@JsonClass(generateAdapter = true)
+internal data class ScanResponse(
+ @Json(name = "clean") val clean: Boolean,
+ /** Human-readable information about the result. */
+ @Json(name = "info") val info: String?
+)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ServerPublicKeyResponse.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ServerPublicKeyResponse.kt
new file mode 100644
index 0000000000..2e97a85bca
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/model/ServerPublicKeyResponse.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.model
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+internal data class ServerPublicKeyResponse(
+ @Json(name = "public_key")
+ val publicKey: String?
+)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/DownloadEncryptedTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/DownloadEncryptedTask.kt
new file mode 100644
index 0000000000..f92c869cb8
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/DownloadEncryptedTask.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.tasks
+
+import okhttp3.ResponseBody
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
+import org.matrix.android.sdk.internal.network.executeRequest
+import org.matrix.android.sdk.internal.session.contentscanner.ContentScannerApiProvider
+import org.matrix.android.sdk.internal.session.contentscanner.ScanEncryptorUtils
+import org.matrix.android.sdk.internal.task.Task
+import javax.inject.Inject
+
+internal interface DownloadEncryptedTask : Task {
+ data class Params(
+ val publicServerKey: String?,
+ val encryptedInfo: ElementToDecrypt,
+ val mxcUrl: String
+ )
+}
+
+internal class DefaultDownloadEncryptedTask @Inject constructor(
+ private val contentScannerApiProvider: ContentScannerApiProvider
+) : DownloadEncryptedTask {
+
+ override suspend fun execute(params: DownloadEncryptedTask.Params): ResponseBody {
+ val dlBody = ScanEncryptorUtils.getDownloadBodyAndEncryptIfNeeded(
+ params.publicServerKey,
+ params.mxcUrl,
+ params.encryptedInfo
+ )
+
+ val api = contentScannerApiProvider.contentScannerApi ?: throw IllegalArgumentException()
+ return executeRequest(null) {
+ api.downloadEncrypted(dlBody)
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/GetServerPublicKeyTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/GetServerPublicKeyTask.kt
new file mode 100644
index 0000000000..41c2ec9c38
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/GetServerPublicKeyTask.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.tasks
+
+import org.matrix.android.sdk.internal.network.executeRequest
+import org.matrix.android.sdk.internal.session.contentscanner.ContentScannerApi
+import org.matrix.android.sdk.internal.session.contentscanner.model.ServerPublicKeyResponse
+import org.matrix.android.sdk.internal.task.Task
+import javax.inject.Inject
+
+internal interface GetServerPublicKeyTask : Task {
+ data class Params(
+ val contentScannerApi: ContentScannerApi
+ )
+}
+
+internal class DefaultGetServerPublicKeyTask @Inject constructor() : GetServerPublicKeyTask {
+
+ override suspend fun execute(params: GetServerPublicKeyTask.Params): String? {
+ return executeRequest(null) {
+ params.contentScannerApi.getServerPublicKey()
+ }.publicKey
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanEncryptedTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanEncryptedTask.kt
new file mode 100644
index 0000000000..dab9b5538f
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanEncryptedTask.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.tasks
+
+import org.matrix.android.sdk.api.failure.toScanFailure
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.internal.crypto.attachments.ElementToDecrypt
+import org.matrix.android.sdk.internal.network.executeRequest
+import org.matrix.android.sdk.internal.session.contentscanner.ContentScannerApiProvider
+import org.matrix.android.sdk.internal.session.contentscanner.ScanEncryptorUtils
+import org.matrix.android.sdk.internal.session.contentscanner.data.ContentScannerStore
+import org.matrix.android.sdk.internal.session.contentscanner.model.ScanResponse
+import org.matrix.android.sdk.internal.task.Task
+import javax.inject.Inject
+
+internal interface ScanEncryptedTask : Task {
+ data class Params(
+ val mxcUrl: String,
+ val publicServerKey: String?,
+ val encryptedInfo: ElementToDecrypt
+ )
+}
+
+internal class DefaultScanEncryptedTask @Inject constructor(
+ private val contentScannerApiProvider: ContentScannerApiProvider,
+ private val contentScannerStore: ContentScannerStore
+) : ScanEncryptedTask {
+
+ override suspend fun execute(params: ScanEncryptedTask.Params): ScanResponse {
+ val mxcUrl = params.mxcUrl
+ val dlBody = ScanEncryptorUtils.getDownloadBodyAndEncryptIfNeeded(params.publicServerKey, params.mxcUrl, params.encryptedInfo)
+
+ val scannerUrl = contentScannerStore.getScannerUrl()
+ contentScannerStore.updateStateForContent(params.mxcUrl, ScanState.IN_PROGRESS, scannerUrl)
+
+ try {
+ val api = contentScannerApiProvider.contentScannerApi ?: throw IllegalArgumentException()
+ val executeRequest = executeRequest(null) {
+ api.scanFile(dlBody)
+ }
+ contentScannerStore.updateScanResultForContent(
+ mxcUrl,
+ scannerUrl,
+ ScanState.TRUSTED.takeIf { executeRequest.clean } ?: ScanState.INFECTED,
+ executeRequest.info ?: ""
+ )
+ return executeRequest
+ } catch (failure: Throwable) {
+ contentScannerStore.updateStateForContent(params.mxcUrl, ScanState.UNKNOWN, scannerUrl)
+ throw failure.toScanFailure() ?: failure
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanMediaTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanMediaTask.kt
new file mode 100644
index 0000000000..505eb7098c
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/contentscanner/tasks/ScanMediaTask.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.internal.session.contentscanner.tasks
+
+import org.matrix.android.sdk.api.MatrixUrls.isMxcUrl
+import org.matrix.android.sdk.api.MatrixUrls.removeMxcPrefix
+import org.matrix.android.sdk.api.failure.toScanFailure
+import org.matrix.android.sdk.api.session.contentscanner.ScanState
+import org.matrix.android.sdk.internal.network.executeRequest
+import org.matrix.android.sdk.internal.session.contentscanner.ContentScannerApiProvider
+import org.matrix.android.sdk.internal.session.contentscanner.data.ContentScannerStore
+import org.matrix.android.sdk.internal.session.contentscanner.model.ScanResponse
+import org.matrix.android.sdk.internal.task.Task
+import javax.inject.Inject
+
+internal interface ScanMediaTask : Task {
+ data class Params(
+ val mxcUrl: String
+ )
+}
+
+internal class DefaultScanMediaTask @Inject constructor(
+ private val contentScannerApiProvider: ContentScannerApiProvider,
+ private val contentScannerStore: ContentScannerStore
+) : ScanMediaTask {
+
+ override suspend fun execute(params: ScanMediaTask.Params): ScanResponse {
+ // "mxc://server.org/QNDpzLopkoQYNikJfoZCQuCXJ"
+ if (!params.mxcUrl.isMxcUrl()) {
+ throw IllegalAccessException("Invalid mxc url")
+ }
+ val scannerUrl = contentScannerStore.getScannerUrl()
+ contentScannerStore.updateStateForContent(params.mxcUrl, ScanState.IN_PROGRESS, scannerUrl)
+
+ var serverAndMediaId = params.mxcUrl.removeMxcPrefix()
+ val fragmentOffset = serverAndMediaId.indexOf("#")
+ if (fragmentOffset >= 0) {
+ serverAndMediaId = serverAndMediaId.substring(0, fragmentOffset)
+ }
+
+ val split = serverAndMediaId.split("/")
+ if (split.size != 2) {
+ throw IllegalAccessException("Invalid mxc url")
+ }
+
+ try {
+ val scanResponse = executeRequest(null) {
+ val api = contentScannerApiProvider.contentScannerApi ?: throw IllegalArgumentException()
+ api.scanMedia(split[0], split[1])
+ }
+ contentScannerStore.updateScanResultForContent(
+ params.mxcUrl,
+ scannerUrl,
+ ScanState.TRUSTED.takeIf { scanResponse.clean } ?: ScanState.INFECTED,
+ scanResponse.info ?: ""
+ )
+ return scanResponse
+ } catch (failure: Throwable) {
+ contentScannerStore.updateStateForContent(params.mxcUrl, ScanState.UNKNOWN, scannerUrl)
+ throw failure.toScanFailure() ?: failure
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/DefaultPushRuleService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/DefaultPushRuleService.kt
index 65974151c8..3e821b8956 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/DefaultPushRuleService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/DefaultPushRuleService.kt
@@ -19,6 +19,7 @@ import androidx.lifecycle.LiveData
import androidx.lifecycle.Transformations
import com.zhuinden.monarchy.Monarchy
import org.matrix.android.sdk.api.pushrules.Action
+import org.matrix.android.sdk.api.pushrules.PushEvents
import org.matrix.android.sdk.api.pushrules.PushRuleService
import org.matrix.android.sdk.api.pushrules.RuleKind
import org.matrix.android.sdk.api.pushrules.RuleScope
@@ -142,79 +143,6 @@ internal class DefaultPushRuleService @Inject constructor(
return pushRuleFinder.fulfilledBingRule(event, rules)?.getActions().orEmpty()
}
-// fun processEvents(events: List) {
-// var hasDoneSomething = false
-// events.forEach { event ->
-// fulfilledBingRule(event)?.let {
-// hasDoneSomething = true
-// dispatchBing(event, it)
-// }
-// }
-// if (hasDoneSomething)
-// dispatchFinish()
-// }
-
- fun dispatchBing(event: Event, rule: PushRule) {
- synchronized(listeners) {
- val actionsList = rule.getActions()
- listeners.forEach {
- try {
- it.onMatchRule(event, actionsList)
- } catch (e: Throwable) {
- Timber.e(e, "Error while dispatching bing")
- }
- }
- }
- }
-
- fun dispatchRoomJoined(roomId: String) {
- synchronized(listeners) {
- listeners.forEach {
- try {
- it.onRoomJoined(roomId)
- } catch (e: Throwable) {
- Timber.e(e, "Error while dispatching room joined")
- }
- }
- }
- }
-
- fun dispatchRoomLeft(roomId: String) {
- synchronized(listeners) {
- listeners.forEach {
- try {
- it.onRoomLeft(roomId)
- } catch (e: Throwable) {
- Timber.e(e, "Error while dispatching room left")
- }
- }
- }
- }
-
- fun dispatchRedactedEventId(redactedEventId: String) {
- synchronized(listeners) {
- listeners.forEach {
- try {
- it.onEventRedacted(redactedEventId)
- } catch (e: Throwable) {
- Timber.e(e, "Error while dispatching redacted event")
- }
- }
- }
- }
-
- fun dispatchFinish() {
- synchronized(listeners) {
- listeners.forEach {
- try {
- it.batchFinish()
- } catch (e: Throwable) {
- Timber.e(e, "Error while dispatching finish")
- }
- }
- }
- }
-
override fun getKeywords(): LiveData> {
// Keywords are all content rules that don't start with '.'
val liveData = monarchy.findAllMappedWithChanges(
@@ -229,4 +157,16 @@ internal class DefaultPushRuleService @Inject constructor(
results.firstOrNull().orEmpty().toSet()
}
}
+
+ fun dispatchEvents(pushEvents: PushEvents) {
+ synchronized(listeners) {
+ listeners.forEach {
+ try {
+ it.onEvents(pushEvents)
+ } catch (e: Throwable) {
+ Timber.e(e, "Error while dispatching push events")
+ }
+ }
+ }
+ }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/ProcessEventForPushTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/ProcessEventForPushTask.kt
index 3c74888eda..0ac21b555e 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/ProcessEventForPushTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/notification/ProcessEventForPushTask.kt
@@ -16,6 +16,7 @@
package org.matrix.android.sdk.internal.session.notification
+import org.matrix.android.sdk.api.pushrules.PushEvents
import org.matrix.android.sdk.api.pushrules.rest.PushRule
import org.matrix.android.sdk.api.session.events.model.EventType
import org.matrix.android.sdk.api.session.events.model.isInvitation
@@ -39,14 +40,6 @@ internal class DefaultProcessEventForPushTask @Inject constructor(
) : ProcessEventForPushTask {
override suspend fun execute(params: ProcessEventForPushTask.Params) {
- // Handle left rooms
- params.syncResponse.leave.keys.forEach {
- defaultPushRuleService.dispatchRoomLeft(it)
- }
- // Handle joined rooms
- params.syncResponse.join.keys.forEach {
- defaultPushRuleService.dispatchRoomJoined(it)
- }
val newJoinEvents = params.syncResponse.join
.mapNotNull { (key, value) ->
value.timeline?.events?.mapNotNull {
@@ -74,10 +67,10 @@ internal class DefaultProcessEventForPushTask @Inject constructor(
}
Timber.v("[PushRules] Found ${allEvents.size} out of ${(newJoinEvents + inviteEvents).size}" +
" to check for push rules with ${params.rules.size} rules")
- allEvents.forEach { event ->
+ val matchedEvents = allEvents.mapNotNull { event ->
pushRuleFinder.fulfilledBingRule(event, params.rules)?.let {
Timber.v("[PushRules] Rule $it match for event ${event.eventId}")
- defaultPushRuleService.dispatchBing(event, it)
+ event to it
}
}
@@ -91,10 +84,13 @@ internal class DefaultProcessEventForPushTask @Inject constructor(
Timber.v("[PushRules] Found ${allRedactedEvents.size} redacted events")
- allRedactedEvents.forEach { redactedEventId ->
- defaultPushRuleService.dispatchRedactedEventId(redactedEventId)
- }
-
- defaultPushRuleService.dispatchFinish()
+ defaultPushRuleService.dispatchEvents(
+ PushEvents(
+ matchedEvents = matchedEvents,
+ roomsJoined = params.syncResponse.join.keys,
+ roomsLeft = params.syncResponse.leave.keys,
+ redactedEventIds = allRedactedEvents
+ )
+ )
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/accountdata/RoomAccountDataDataSource.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/accountdata/RoomAccountDataDataSource.kt
index 0e4493846c..d96beed3f1 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/accountdata/RoomAccountDataDataSource.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/accountdata/RoomAccountDataDataSource.kt
@@ -43,7 +43,7 @@ internal class RoomAccountDataDataSource @Inject constructor(@SessionDatabase pr
fun getLiveAccountDataEvent(roomId: String, type: String): LiveData> {
return Transformations.map(getLiveAccountDataEvents(roomId, setOf(type))) {
- it.firstOrNull()?.toOptional()
+ it.firstOrNull().toOptional()
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
index 177c98541c..77aadef6bd 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
@@ -37,7 +37,6 @@ import org.matrix.android.sdk.api.session.room.model.message.MessageFileContent
import org.matrix.android.sdk.api.session.room.model.message.MessageImageContent
import org.matrix.android.sdk.api.session.room.model.message.MessageVideoContent
import org.matrix.android.sdk.api.session.room.model.message.MessageWithAttachmentContent
-import org.matrix.android.sdk.api.session.room.model.message.OptionItem
import org.matrix.android.sdk.api.session.room.model.message.getFileUrl
import org.matrix.android.sdk.api.session.room.send.SendService
import org.matrix.android.sdk.api.session.room.send.SendState
@@ -98,7 +97,7 @@ internal class DefaultSendService @AssistedInject constructor(
.let { sendEvent(it) }
}
- override fun sendPoll(question: String, options: List): Cancelable {
+ override fun sendPoll(question: String, options: List): Cancelable {
return localEchoEventFactory.createPollEvent(roomId, question, options)
.also { createLocalEcho(it) }
.let { sendEvent(it) }
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/LocalEchoEventFactory.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/LocalEchoEventFactory.kt
index 8dd0c59387..5cb9687518 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/LocalEchoEventFactory.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/LocalEchoEventFactory.kt
@@ -38,13 +38,14 @@ import org.matrix.android.sdk.api.session.room.model.message.MessageContentWithF
import org.matrix.android.sdk.api.session.room.model.message.MessageFileContent
import org.matrix.android.sdk.api.session.room.model.message.MessageFormat
import org.matrix.android.sdk.api.session.room.model.message.MessageImageContent
-import org.matrix.android.sdk.api.session.room.model.message.MessageOptionsContent
+import org.matrix.android.sdk.api.session.room.model.message.MessagePollContent
import org.matrix.android.sdk.api.session.room.model.message.MessagePollResponseContent
import org.matrix.android.sdk.api.session.room.model.message.MessageTextContent
import org.matrix.android.sdk.api.session.room.model.message.MessageType
import org.matrix.android.sdk.api.session.room.model.message.MessageVideoContent
-import org.matrix.android.sdk.api.session.room.model.message.OPTION_TYPE_POLL
-import org.matrix.android.sdk.api.session.room.model.message.OptionItem
+import org.matrix.android.sdk.api.session.room.model.message.PollAnswer
+import org.matrix.android.sdk.api.session.room.model.message.PollCreationInfo
+import org.matrix.android.sdk.api.session.room.model.message.PollQuestion
import org.matrix.android.sdk.api.session.room.model.message.ThumbnailInfo
import org.matrix.android.sdk.api.session.room.model.message.VideoInfo
import org.matrix.android.sdk.api.session.room.model.relation.ReactionContent
@@ -138,24 +139,29 @@ internal class LocalEchoEventFactory @Inject constructor(
fun createPollEvent(roomId: String,
question: String,
- options: List): Event {
- val compatLabel = buildString {
- append("[Poll] ")
- append(question)
- options.forEach {
- append("\n")
- append(it.value)
- }
- }
- return createMessageEvent(
- roomId,
- MessageOptionsContent(
- body = compatLabel,
- label = question,
- optionType = OPTION_TYPE_POLL,
- options = options.toList()
+ options: List): Event {
+ val content = MessagePollContent(
+ pollCreationInfo = PollCreationInfo(
+ question = PollQuestion(
+ question = question
+ ),
+ answers = options.mapIndexed { index, option ->
+ PollAnswer(
+ id = index.toString(),
+ answer = option
+ )
+ }
)
)
+ val localId = LocalEcho.createLocalEchoId()
+ return Event(
+ roomId = roomId,
+ originServerTs = dummyOriginServerTs(),
+ senderId = userId,
+ eventId = localId,
+ type = EventType.POLL_START,
+ content = content.toContent(),
+ unsignedData = UnsignedData(age = null, transactionId = localId))
}
fun createReplaceTextOfReply(roomId: String,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/signout/SignOutTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/signout/SignOutTask.kt
index 19f34746ab..7ac34e80e9 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/signout/SignOutTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/signout/SignOutTask.kt
@@ -43,6 +43,7 @@ internal class DefaultSignOutTask @Inject constructor(
override suspend fun execute(params: SignOutTask.Params) {
// It should be done even after a soft logout, to be sure the deviceId is deleted on the
if (params.signOutFromHomeserver) {
+ cleanupSession.stopActiveTasks()
Timber.d("SignOut: send request...")
try {
executeRequest(globalErrorReceiver) {
@@ -67,6 +68,6 @@ internal class DefaultSignOutTask @Inject constructor(
.onFailure { Timber.w(it, "Unable to disconnect identity server") }
Timber.d("SignOut: cleanup session...")
- cleanupSession.handle()
+ cleanupSession.cleanup()
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/SyncResponseHandler.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/SyncResponseHandler.kt
index 335f619623..8fd969e373 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/SyncResponseHandler.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/SyncResponseHandler.kt
@@ -24,11 +24,13 @@ import org.matrix.android.sdk.api.session.initsync.InitSyncStep
import org.matrix.android.sdk.api.session.sync.model.GroupsSyncResponse
import org.matrix.android.sdk.api.session.sync.model.RoomsSyncResponse
import org.matrix.android.sdk.api.session.sync.model.SyncResponse
+import org.matrix.android.sdk.internal.SessionManager
import org.matrix.android.sdk.internal.crypto.DefaultCryptoService
import org.matrix.android.sdk.internal.di.SessionDatabase
import org.matrix.android.sdk.internal.di.SessionId
import org.matrix.android.sdk.internal.di.WorkManagerProvider
import org.matrix.android.sdk.internal.session.SessionListeners
+import org.matrix.android.sdk.internal.session.dispatchTo
import org.matrix.android.sdk.internal.session.group.GetGroupDataWorker
import org.matrix.android.sdk.internal.session.initsync.ProgressReporter
import org.matrix.android.sdk.internal.session.initsync.reportSubtask
@@ -51,6 +53,7 @@ private const val GET_GROUP_DATA_WORKER = "GET_GROUP_DATA_WORKER"
internal class SyncResponseHandler @Inject constructor(
@SessionDatabase private val monarchy: Monarchy,
@SessionId private val sessionId: String,
+ private val sessionManager: SessionManager,
private val sessionListeners: SessionListeners,
private val workManagerProvider: WorkManagerProvider,
private val roomSyncHandler: RoomSyncHandler,
@@ -158,8 +161,9 @@ internal class SyncResponseHandler @Inject constructor(
}
private fun dispatchInvitedRoom(roomsSyncResponse: RoomsSyncResponse) {
+ val session = sessionManager.getSessionComponent(sessionId)?.session()
roomsSyncResponse.invite.keys.forEach { roomId ->
- sessionListeners.dispatch { session, listener ->
+ session.dispatchTo(sessionListeners) { session, listener ->
listener.onNewInvitedRoom(session, roomId)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
index e1150f2c47..3faa0c9488 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
@@ -160,6 +160,9 @@ internal class SyncThread @Inject constructor(private val syncTask: SyncTask,
synchronized(lock) { lock.wait() }
Timber.tag(loggerTag.value).d("...retry")
} else if (!isTokenValid) {
+ if (state == SyncState.Killing) {
+ continue
+ }
Timber.tag(loggerTag.value).d("Token is invalid. Waiting...")
updateStateTo(SyncState.InvalidToken)
synchronized(lock) { lock.wait() }
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/user/accountdata/UserAccountDataDataSource.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/user/accountdata/UserAccountDataDataSource.kt
index b36bdc80f8..2c3d660333 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/user/accountdata/UserAccountDataDataSource.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/user/accountdata/UserAccountDataDataSource.kt
@@ -41,7 +41,7 @@ internal class UserAccountDataDataSource @Inject constructor(@SessionDatabase pr
fun getLiveAccountDataEvent(type: String): LiveData> {
return Transformations.map(getLiveAccountDataEvents(setOf(type))) {
- it.firstOrNull()?.toOptional()
+ it.firstOrNull().toOptional()
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
index a12587ac56..3e977b31fb 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
@@ -16,9 +16,8 @@
package org.matrix.android.sdk.internal.util
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import org.matrix.android.sdk.internal.di.MatrixScope
import timber.log.Timber
import javax.inject.Inject
@@ -27,13 +26,12 @@ import javax.inject.Inject
* To be attached to ProcessLifecycleOwner lifecycle
*/
@MatrixScope
-internal class BackgroundDetectionObserver @Inject constructor() : LifecycleObserver {
+internal class BackgroundDetectionObserver @Inject constructor() : DefaultLifecycleObserver {
var isInBackground: Boolean = true
private set
- private
- val listeners = LinkedHashSet()
+ private val listeners = LinkedHashSet()
fun register(listener: Listener) {
listeners.add(listener)
@@ -43,15 +41,13 @@ internal class BackgroundDetectionObserver @Inject constructor() : LifecycleObse
listeners.remove(listener)
}
- @OnLifecycleEvent(Lifecycle.Event.ON_START)
- fun onMoveToForeground() {
+ override fun onStart(owner: LifecycleOwner) {
Timber.v("App returning to foreground…")
isInBackground = false
listeners.forEach { it.onMoveToForeground() }
}
- @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
- fun onMoveToBackground() {
+ override fun onStop(owner: LifecycleOwner) {
Timber.v("App going to background…")
isInBackground = true
listeners.forEach { it.onMoveToBackground() }
diff --git a/multipicker/src/main/java/im/vector/lib/multipicker/ContactPicker.kt b/multipicker/src/main/java/im/vector/lib/multipicker/ContactPicker.kt
index 315fe6cbf2..2b8c1d11e6 100644
--- a/multipicker/src/main/java/im/vector/lib/multipicker/ContactPicker.kt
+++ b/multipicker/src/main/java/im/vector/lib/multipicker/ContactPicker.kt
@@ -21,6 +21,7 @@ import android.content.Context
import android.content.Intent
import android.provider.ContactsContract
import im.vector.lib.multipicker.entity.MultiPickerContactType
+import im.vector.lib.multipicker.utils.getColumnIndexOrNull
/**
* Contact Picker implementation
@@ -49,9 +50,9 @@ class ContactPicker : Picker() {
null
)?.use { cursor ->
if (cursor.moveToFirst()) {
- val idColumn = cursor.getColumnIndex(ContactsContract.Contacts._ID)
- val nameColumn = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)
- val photoUriColumn = cursor.getColumnIndex(ContactsContract.Contacts.PHOTO_URI)
+ val idColumn = cursor.getColumnIndexOrNull(ContactsContract.Contacts._ID) ?: return@use
+ val nameColumn = cursor.getColumnIndexOrNull(ContactsContract.Contacts.DISPLAY_NAME) ?: return@use
+ val photoUriColumn = cursor.getColumnIndexOrNull(ContactsContract.Contacts.PHOTO_URI) ?: return@use
val contactId = cursor.getInt(idColumn)
var name = cursor.getString(nameColumn)
@@ -72,10 +73,13 @@ class ContactPicker : Picker() {
selection,
selectionArgs,
null
- )?.use { cursor ->
- while (cursor.moveToNext()) {
- val mimeType = cursor.getString(cursor.getColumnIndex(ContactsContract.Data.MIMETYPE))
- val contactData = cursor.getString(cursor.getColumnIndex(ContactsContract.Data.DATA1))
+ )?.use inner@{ innerCursor ->
+ val mimeTypeColumnIndex = innerCursor.getColumnIndexOrNull(ContactsContract.Data.MIMETYPE) ?: return@inner
+ val data1ColumnIndex = innerCursor.getColumnIndexOrNull(ContactsContract.Data.DATA1) ?: return@inner
+
+ while (innerCursor.moveToNext()) {
+ val mimeType = innerCursor.getString(mimeTypeColumnIndex)
+ val contactData = innerCursor.getString(data1ColumnIndex)
if (mimeType == ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) {
name = contactData
@@ -115,7 +119,10 @@ class ContactPicker : Picker() {
selectionArgs,
null
)?.use { cursor ->
- return if (cursor.moveToFirst()) cursor.getInt(cursor.getColumnIndex(ContactsContract.RawContacts._ID)) else null
+ return if (cursor.moveToFirst()) {
+ cursor.getColumnIndexOrNull(ContactsContract.RawContacts._ID)
+ ?.let { cursor.getInt(it) }
+ } else null
}
}
diff --git a/multipicker/src/main/java/im/vector/lib/multipicker/FilePicker.kt b/multipicker/src/main/java/im/vector/lib/multipicker/FilePicker.kt
index ec98152aa7..8e6c97f2f8 100644
--- a/multipicker/src/main/java/im/vector/lib/multipicker/FilePicker.kt
+++ b/multipicker/src/main/java/im/vector/lib/multipicker/FilePicker.kt
@@ -21,6 +21,7 @@ import android.content.Intent
import android.provider.OpenableColumns
import im.vector.lib.multipicker.entity.MultiPickerBaseType
import im.vector.lib.multipicker.entity.MultiPickerFileType
+import im.vector.lib.multipicker.utils.getColumnIndexOrNull
import im.vector.lib.multipicker.utils.isMimeTypeAudio
import im.vector.lib.multipicker.utils.isMimeTypeImage
import im.vector.lib.multipicker.utils.isMimeTypeVideo
@@ -49,8 +50,8 @@ class FilePicker : Picker() {
// Other files
context.contentResolver.query(selectedUri, null, null, null, null)
?.use { cursor ->
- val nameColumn = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
- val sizeColumn = cursor.getColumnIndex(OpenableColumns.SIZE)
+ val nameColumn = cursor.getColumnIndexOrNull(OpenableColumns.DISPLAY_NAME) ?: return@use null
+ val sizeColumn = cursor.getColumnIndexOrNull(OpenableColumns.SIZE) ?: return@use null
if (cursor.moveToFirst()) {
val name = cursor.getString(nameColumn)
val size = cursor.getLong(sizeColumn)
diff --git a/multipicker/src/main/java/im/vector/lib/multipicker/utils/ContentResolverUtil.kt b/multipicker/src/main/java/im/vector/lib/multipicker/utils/ContentResolverUtil.kt
index 78136c274a..55c0010afd 100644
--- a/multipicker/src/main/java/im/vector/lib/multipicker/utils/ContentResolverUtil.kt
+++ b/multipicker/src/main/java/im/vector/lib/multipicker/utils/ContentResolverUtil.kt
@@ -37,8 +37,8 @@ internal fun Uri.toMultiPickerImageType(context: Context): MultiPickerImageType?
null,
null
)?.use { cursor ->
- val nameColumn = cursor.getColumnIndex(MediaStore.Images.Media.DISPLAY_NAME)
- val sizeColumn = cursor.getColumnIndex(MediaStore.Images.Media.SIZE)
+ val nameColumn = cursor.getColumnIndexOrNull(MediaStore.Images.Media.DISPLAY_NAME) ?: return@use null
+ val sizeColumn = cursor.getColumnIndexOrNull(MediaStore.Images.Media.SIZE) ?: return@use null
if (cursor.moveToNext()) {
val name = cursor.getString(nameColumn)
@@ -75,8 +75,8 @@ internal fun Uri.toMultiPickerVideoType(context: Context): MultiPickerVideoType?
null,
null
)?.use { cursor ->
- val nameColumn = cursor.getColumnIndex(MediaStore.Video.Media.DISPLAY_NAME)
- val sizeColumn = cursor.getColumnIndex(MediaStore.Video.Media.SIZE)
+ val nameColumn = cursor.getColumnIndexOrNull(MediaStore.Video.Media.DISPLAY_NAME) ?: return@use null
+ val sizeColumn = cursor.getColumnIndexOrNull(MediaStore.Video.Media.SIZE) ?: return@use null
if (cursor.moveToNext()) {
val name = cursor.getString(nameColumn)
@@ -124,8 +124,8 @@ fun Uri.toMultiPickerAudioType(context: Context): MultiPickerAudioType? {
null,
null
)?.use { cursor ->
- val nameColumn = cursor.getColumnIndex(MediaStore.Audio.Media.DISPLAY_NAME)
- val sizeColumn = cursor.getColumnIndex(MediaStore.Audio.Media.SIZE)
+ val nameColumn = cursor.getColumnIndexOrNull(MediaStore.Audio.Media.DISPLAY_NAME) ?: return@use null
+ val sizeColumn = cursor.getColumnIndexOrNull(MediaStore.Audio.Media.SIZE) ?: return@use null
if (cursor.moveToNext()) {
val name = cursor.getString(nameColumn)
diff --git a/multipicker/src/main/java/im/vector/lib/multipicker/utils/CursorExtensions.kt b/multipicker/src/main/java/im/vector/lib/multipicker/utils/CursorExtensions.kt
new file mode 100644
index 0000000000..87cf48d0a7
--- /dev/null
+++ b/multipicker/src/main/java/im/vector/lib/multipicker/utils/CursorExtensions.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2021 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.lib.multipicker.utils
+
+import android.database.Cursor
+
+fun Cursor.getColumnIndexOrNull(column: String): Int? {
+ return getColumnIndex(column).takeIf { it != -1 }
+}
diff --git a/tools/check/forbidden_strings_in_code.txt b/tools/check/forbidden_strings_in_code.txt
index 29077c3a76..b135954f63 100644
--- a/tools/check/forbidden_strings_in_code.txt
+++ b/tools/check/forbidden_strings_in_code.txt
@@ -160,7 +160,7 @@ Formatter\.formatShortFileSize===1
# android\.text\.TextUtils
### This is not a rule, but a warning: the number of "enum class" has changed. For Json classes, it is mandatory that they have `@JsonClass(generateAdapter = false)`. If the enum is not used as a Json class, change the value in file forbidden_strings_in_code.txt
-enum class===107
+enum class===108
### Do not import temporary legacy classes
import org.matrix.android.sdk.internal.legacy.riot===3
diff --git a/tools/emojis/emoji_picker_datasource_formatted.json b/tools/emojis/emoji_picker_datasource_formatted.json
index 4f3038d53c..341cdc0c54 100644
--- a/tools/emojis/emoji_picker_datasource_formatted.json
+++ b/tools/emojis/emoji_picker_datasource_formatted.json
@@ -4191,7 +4191,8 @@
"call",
"hand",
"hands",
- "gesture"
+ "gesture",
+ "shaka"
]
},
"backhand-index-pointing-left": {
diff --git a/tools/release/sign_apk.sh b/tools/release/sign_apk.sh
index 7697f58ceb..aae9e1a378 100755
--- a/tools/release/sign_apk.sh
+++ b/tools/release/sign_apk.sh
@@ -17,7 +17,7 @@ PARAM_KEYSTORE_PATH=$1
PARAM_APK=$2
# Other params
-BUILD_TOOLS_VERSION="30.0.3"
+BUILD_TOOLS_VERSION="31.0.0-rc5"
MIN_SDK_VERSION=21
echo "Signing APK with build-tools version ${BUILD_TOOLS_VERSION} for min SDK version ${MIN_SDK_VERSION}..."
diff --git a/tools/release/sign_apk_unsafe.sh b/tools/release/sign_apk_unsafe.sh
index af5b0f0e32..5d209a4a2b 100755
--- a/tools/release/sign_apk_unsafe.sh
+++ b/tools/release/sign_apk_unsafe.sh
@@ -23,7 +23,7 @@ PARAM_KS_PASS=$3
PARAM_KEY_PASS=$4
# Other params
-BUILD_TOOLS_VERSION="30.0.3"
+BUILD_TOOLS_VERSION="31.0.0-rc5"
MIN_SDK_VERSION=21
echo "Signing APK with build-tools version ${BUILD_TOOLS_VERSION} for min SDK version ${MIN_SDK_VERSION}..."
diff --git a/vector/build.gradle b/vector/build.gradle
index 03b35465bf..655cff2e73 100644
--- a/vector/build.gradle
+++ b/vector/build.gradle
@@ -15,7 +15,7 @@ kapt {
// Note: 2 digits max for each value
ext.versionMajor = 1
ext.versionMinor = 3
-ext.versionPatch = 7
+ext.versionPatch = 8
static def getGitTimestamp() {
def cmd = 'git show -s --format=%ct'
@@ -105,7 +105,6 @@ def buildNumber = System.env.BUILDKITE_BUILD_NUMBER as Integer ?: 0
android {
-
// Due to a bug introduced in Android gradle plugin 3.6.0, we have to specify the ndk version to use
// Ref: https://issuetracker.google.com/issues/144111441
ndkVersion "21.3.6528147"
@@ -211,6 +210,7 @@ android {
// This property does not affect tests that you run using Android Studio.”
animationsDisabled = true
+ // Comment to run on Android 12
execution 'ANDROIDX_TEST_ORCHESTRATOR'
}
@@ -333,7 +333,6 @@ configurations {
dependencies {
implementation project(":matrix-sdk-android")
- implementation project(":matrix-sdk-android-rx")
implementation project(":matrix-sdk-android-flow")
implementation project(":diff-match-patch")
implementation project(":multipicker")
@@ -358,8 +357,10 @@ dependencies {
implementation libs.squareup.moshi
kapt libs.squareup.moshiKotlin
- implementation libs.androidx.lifecycleExtensions
+
+ // Lifecycle
implementation libs.androidx.lifecycleLivedata
+ implementation libs.androidx.lifecycleProcess
implementation libs.androidx.datastore
implementation libs.androidx.datastorepreferences
@@ -372,25 +373,18 @@ dependencies {
implementation 'com.facebook.stetho:stetho:1.6.0'
// Phone number https://github.com/google/libphonenumber
- implementation 'com.googlecode.libphonenumber:libphonenumber:8.12.36'
+ implementation 'com.googlecode.libphonenumber:libphonenumber:8.12.37'
- // rx
- implementation libs.rx.rxKotlin
- implementation libs.rx.rxAndroid
- implementation 'com.jakewharton.rxrelay2:rxrelay:2.1.1'
- // RXBinding
- implementation libs.jakewharton.rxbinding
- implementation libs.jakewharton.rxbindingAppcompat
- implementation libs.jakewharton.rxbindingMaterial
+ // FlowBinding
+ implementation libs.github.flowBinding
+ implementation libs.github.flowBindingAppcompat
+ implementation libs.github.flowBindingMaterial
implementation libs.airbnb.epoxy
implementation libs.airbnb.epoxyGlide
kapt libs.airbnb.epoxyProcessor
implementation libs.airbnb.epoxyPaging
implementation libs.airbnb.mavericks
- //TODO: remove when entirely migrated to Flow
- implementation libs.airbnb.mavericksRx
-
// Work
implementation libs.androidx.work
@@ -420,7 +414,7 @@ dependencies {
implementation 'com.github.Armen101:AudioRecordView:1.0.5'
// Custom Tab
- implementation 'androidx.browser:browser:1.3.0'
+ implementation 'androidx.browser:browser:1.4.0'
// Passphrase strength helper
implementation 'com.nulab-inc:zxcvbn:1.5.2'
@@ -471,7 +465,7 @@ dependencies {
gplayImplementation 'com.google.android.gms:play-services-oss-licenses:17.0.0'
implementation "androidx.emoji:emoji-appcompat:1.1.0"
- implementation ('com.github.BillCarsonFr:JsonViewer:0.7')
+ implementation('com.github.BillCarsonFr:JsonViewer:0.7')
// WebRTC
// org.webrtc:google-webrtc is for development purposes only
@@ -512,6 +506,9 @@ dependencies {
// Plant Timber tree for test
testImplementation libs.tests.timberJunitRule
testImplementation libs.airbnb.mavericksTesting
+ testImplementation(libs.jetbrains.coroutinesTest) {
+ exclude group: "org.jetbrains.kotlinx", module: "kotlinx-coroutines-debug"
+ }
// Activate when you want to check for leaks, from time to time.
//debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.3'
@@ -525,6 +522,9 @@ dependencies {
androidTestImplementation libs.androidx.espressoIntents
androidTestImplementation libs.tests.kluent
androidTestImplementation libs.androidx.coreTesting
+ androidTestImplementation(libs.jetbrains.coroutinesTest) {
+ exclude group: "org.jetbrains.kotlinx", module: "kotlinx-coroutines-debug"
+ }
// Plant Timber tree for test
androidTestImplementation libs.tests.timberJunitRule
// "The one who serves a great Espresso"
diff --git a/vector/lint.xml b/vector/lint.xml
index dde29af62e..e534bdc355 100644
--- a/vector/lint.xml
+++ b/vector/lint.xml
@@ -68,6 +68,7 @@
+
diff --git a/vector/src/androidTest/java/im/vector/app/EspressoExt.kt b/vector/src/androidTest/java/im/vector/app/EspressoExt.kt
index 823ce83015..fbcb9b8cb3 100644
--- a/vector/src/androidTest/java/im/vector/app/EspressoExt.kt
+++ b/vector/src/androidTest/java/im/vector/app/EspressoExt.kt
@@ -18,7 +18,10 @@ package im.vector.app
import android.app.Activity
import android.view.View
+import androidx.annotation.StringRes
+import androidx.fragment.app.FragmentActivity
import androidx.lifecycle.Observer
+import androidx.test.espresso.Espresso
import androidx.test.espresso.IdlingRegistry
import androidx.test.espresso.IdlingResource
import androidx.test.espresso.PerformException
@@ -32,6 +35,12 @@ import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
import androidx.test.runner.lifecycle.ActivityLifecycleCallback
import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry
import androidx.test.runner.lifecycle.Stage
+import com.adevinta.android.barista.interaction.BaristaClickInteractions
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.bottomsheet.BottomSheetDialog
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import im.vector.app.core.platform.VectorBaseBottomSheetDialogFragment
+import im.vector.app.espresso.tools.waitUntilViewVisible
import org.hamcrest.Matcher
import org.hamcrest.Matchers
import org.hamcrest.StringDescription
@@ -49,6 +58,18 @@ object EspressoHelper {
}
return currentActivity
}
+
+ inline fun > getBottomSheetDialog(): BottomSheetDialogFragment? {
+ return (getCurrentActivity() as? FragmentActivity)
+ ?.supportFragmentManager
+ ?.fragments
+ ?.filterIsInstance()
+ ?.firstOrNull()
+ }
+}
+
+fun getString(@StringRes id: Int): String {
+ return EspressoHelper.getCurrentActivity()!!.resources.getString(id)
}
fun waitForView(viewMatcher: Matcher, timeout: Long = 10_000, waitForDisplayed: Boolean = true): ViewAction {
@@ -70,6 +91,8 @@ fun waitForView(viewMatcher: Matcher, timeout: Long = 10_000, waitForDispl
val endTime = startTime + timeout
val visibleMatcher = isDisplayed()
+ uiController.loopMainThreadForAtLeast(100)
+
do {
println("*** waitForView loop $view end:$endTime current:${System.currentTimeMillis()}")
val viewVisible = TreeIterables.breadthFirstViewTraversal(view)
@@ -205,3 +228,52 @@ fun allSecretsKnownIdling(session: Session): IdlingResource {
return res
}
+
+fun clickOnAndGoBack(@StringRes name: Int, block: () -> Unit) {
+ BaristaClickInteractions.clickOn(name)
+ block()
+ Espresso.pressBack()
+}
+
+inline fun > interactWithSheet(contentMatcher: Matcher, noinline block: () -> Unit = {}) {
+ waitUntilViewVisible(contentMatcher)
+ val behaviour = (EspressoHelper.getBottomSheetDialog()!!.dialog as BottomSheetDialog).behavior
+ withIdlingResource(BottomSheetResource(behaviour, BottomSheetBehavior.STATE_EXPANDED), block)
+ withIdlingResource(BottomSheetResource(behaviour, BottomSheetBehavior.STATE_HIDDEN)) {}
+}
+
+class BottomSheetResource(
+ private val bottomSheetBehavior: BottomSheetBehavior<*>,
+ @BottomSheetBehavior.State private val wantedState: Int
+) : IdlingResource, BottomSheetBehavior.BottomSheetCallback() {
+
+ private var isIdle: Boolean = false
+ private var resourceCallback: IdlingResource.ResourceCallback? = null
+
+ override fun onSlide(bottomSheet: View, slideOffset: Float) {}
+
+ override fun onStateChanged(bottomSheet: View, newState: Int) {
+ val wasIdle = isIdle
+ isIdle = newState == BottomSheetBehavior.STATE_EXPANDED
+ if (!wasIdle && isIdle) {
+ bottomSheetBehavior.removeBottomSheetCallback(this)
+ resourceCallback?.onTransitionToIdle()
+ }
+ }
+
+ override fun getName() = "BottomSheet awaiting state: $wantedState"
+
+ override fun isIdleNow() = isIdle
+
+ override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback) {
+ resourceCallback = callback
+
+ val state = bottomSheetBehavior.state
+ isIdle = state == wantedState
+ if (isIdle) {
+ resourceCallback!!.onTransitionToIdle()
+ } else {
+ bottomSheetBehavior.addBottomSheetCallback(this)
+ }
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/VerificationTestBase.kt b/vector/src/androidTest/java/im/vector/app/VerificationTestBase.kt
index a562287263..47e1e43be3 100644
--- a/vector/src/androidTest/java/im/vector/app/VerificationTestBase.kt
+++ b/vector/src/androidTest/java/im/vector/app/VerificationTestBase.kt
@@ -18,7 +18,7 @@ package im.vector.app
import android.net.Uri
import androidx.lifecycle.Observer
-import im.vector.app.ui.UiTestBase
+import im.vector.app.ui.robot.OnboardingRobot
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
@@ -39,7 +39,7 @@ abstract class VerificationTestBase {
val password = "password"
val homeServerUrl: String = "http://10.0.2.2:8080"
- protected val uiTestBase = UiTestBase()
+ protected val uiTestBase = OnboardingRobot()
fun createAccountAndSync(matrix: Matrix,
userName: String,
diff --git a/vector/src/androidTest/java/im/vector/app/espresso/tools/ScreenshotFailureRule.kt b/vector/src/androidTest/java/im/vector/app/espresso/tools/ScreenshotFailureRule.kt
new file mode 100644
index 0000000000..2e329ebb6b
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/espresso/tools/ScreenshotFailureRule.kt
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2021 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.app.espresso.tools
+
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
+import org.junit.rules.TestWatcher
+import org.junit.runner.Description
+import timber.log.Timber
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+private val SCREENSHOT_FOLDER_LOCATION = "${Environment.DIRECTORY_PICTURES}/failure_screenshots"
+private val deviceLanguage = Locale.getDefault().language
+
+class ScreenshotFailureRule : TestWatcher() {
+ override fun failed(e: Throwable?, description: Description) {
+ val screenShotName = "$deviceLanguage-${description.methodName}-${SimpleDateFormat("EEE-MMMM-dd-HH:mm:ss").format(Date())}"
+ val bitmap = getInstrumentation().uiAutomation.takeScreenshot()
+ storeFailureScreenshot(bitmap, screenShotName)
+ }
+}
+
+/**
+ * Stores screenshots in sdcard/Pictures/failure_screenshots
+ */
+private fun storeFailureScreenshot(bitmap: Bitmap, screenshotName: String) {
+ val contentResolver = getInstrumentation().targetContext.applicationContext.contentResolver
+
+ val contentValues = ContentValues().apply {
+ put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
+ put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis())
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ useMediaStoreScreenshotStorage(
+ contentValues,
+ contentResolver,
+ screenshotName,
+ SCREENSHOT_FOLDER_LOCATION,
+ bitmap
+ )
+ } else {
+ usePublicExternalScreenshotStorage(
+ contentValues,
+ contentResolver,
+ screenshotName,
+ SCREENSHOT_FOLDER_LOCATION,
+ bitmap
+ )
+ }
+}
+
+private fun useMediaStoreScreenshotStorage(
+ contentValues: ContentValues,
+ contentResolver: ContentResolver,
+ screenshotName: String,
+ screenshotLocation: String,
+ bitmap: Bitmap
+) {
+ contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, "$screenshotName.jpeg")
+ contentValues.put(MediaStore.Images.Media.RELATIVE_PATH, screenshotLocation)
+ val uri: Uri? = contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
+ if (uri != null) {
+ contentResolver.openOutputStream(uri)?.let { saveScreenshotToStream(bitmap, it) }
+ contentResolver.update(uri, contentValues, null, null)
+ }
+}
+
+@Suppress("DEPRECATION")
+private fun usePublicExternalScreenshotStorage(
+ contentValues: ContentValues,
+ contentResolver: ContentResolver,
+ screenshotName: String,
+ screenshotLocation: String,
+ bitmap: Bitmap
+) {
+ val directory = File(Environment.getExternalStoragePublicDirectory(screenshotLocation).toString())
+ if (!directory.exists()) {
+ directory.mkdirs()
+ }
+ val file = File(directory, "$screenshotName.jpeg")
+ saveScreenshotToStream(bitmap, FileOutputStream(file))
+ contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
+}
+
+private fun saveScreenshotToStream(bitmap: Bitmap, outputStream: OutputStream) {
+ outputStream.use {
+ try {
+ bitmap.compress(Bitmap.CompressFormat.JPEG, 50, it)
+ } catch (e: IOException) {
+ Timber.e("Screenshot was not stored at this time")
+ }
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/espresso/tools/WaitActivity.kt b/vector/src/androidTest/java/im/vector/app/espresso/tools/WaitActivity.kt
index 2cdca62c74..7744d4b720 100644
--- a/vector/src/androidTest/java/im/vector/app/espresso/tools/WaitActivity.kt
+++ b/vector/src/androidTest/java/im/vector/app/espresso/tools/WaitActivity.kt
@@ -17,9 +17,18 @@
package im.vector.app.espresso.tools
import android.app.Activity
+import android.view.View
+import androidx.test.espresso.Espresso
+import androidx.test.espresso.matcher.ViewMatchers
import im.vector.app.activityIdlingResource
+import im.vector.app.waitForView
import im.vector.app.withIdlingResource
+import org.hamcrest.Matcher
-inline fun waitUntilActivityVisible(noinline block: (() -> Unit)) {
+inline fun waitUntilActivityVisible(noinline block: (() -> Unit) = {}) {
withIdlingResource(activityIdlingResource(T::class.java), block)
}
+
+fun waitUntilViewVisible(viewMatcher: Matcher) {
+ Espresso.onView(ViewMatchers.isRoot()).perform(waitForView(viewMatcher))
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/UiAllScreensSanityTest.kt b/vector/src/androidTest/java/im/vector/app/ui/UiAllScreensSanityTest.kt
index a9cb5274ed..f998a9f23c 100644
--- a/vector/src/androidTest/java/im/vector/app/ui/UiAllScreensSanityTest.kt
+++ b/vector/src/androidTest/java/im/vector/app/ui/UiAllScreensSanityTest.kt
@@ -16,53 +16,19 @@
package im.vector.app.ui
-import android.view.View
-import androidx.recyclerview.widget.RecyclerView
-import androidx.test.espresso.Espresso.onView
-import androidx.test.espresso.Espresso.pressBack
-import androidx.test.espresso.action.ViewActions.closeSoftKeyboard
-import androidx.test.espresso.action.ViewActions.longClick
-import androidx.test.espresso.contrib.RecyclerViewActions.actionOnItem
-import androidx.test.espresso.matcher.ViewMatchers.hasDescendant
-import androidx.test.espresso.matcher.ViewMatchers.isRoot
-import androidx.test.espresso.matcher.ViewMatchers.withId
-import androidx.test.espresso.matcher.ViewMatchers.withText
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
-import com.adevinta.android.barista.assertion.BaristaListAssertions.assertListItemCount
-import com.adevinta.android.barista.assertion.BaristaVisibilityAssertions.assertDisplayed
-import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickBack
-import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
-import com.adevinta.android.barista.interaction.BaristaClickInteractions.longClickOn
-import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
-import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogPositiveButton
-import com.adevinta.android.barista.interaction.BaristaDrawerInteractions.openDrawer
-import com.adevinta.android.barista.interaction.BaristaEditTextInteractions.writeTo
-import com.adevinta.android.barista.interaction.BaristaListInteractions.clickListItem
-import com.adevinta.android.barista.interaction.BaristaListInteractions.clickListItemChild
-import com.adevinta.android.barista.interaction.BaristaMenuClickInteractions.clickMenu
-import com.adevinta.android.barista.interaction.BaristaMenuClickInteractions.openMenu
-import im.vector.app.BuildConfig
-import im.vector.app.EspressoHelper
import im.vector.app.R
-import im.vector.app.SleepViewAction
-import im.vector.app.activityIdlingResource
-import im.vector.app.espresso.tools.clickOnPreference
-import im.vector.app.espresso.tools.waitUntilActivityVisible
+import im.vector.app.espresso.tools.ScreenshotFailureRule
import im.vector.app.features.MainActivity
-import im.vector.app.features.createdirect.CreateDirectRoomActivity
-import im.vector.app.features.home.HomeActivity
-import im.vector.app.features.home.room.detail.RoomDetailActivity
-import im.vector.app.features.login.LoginActivity
-import im.vector.app.features.roomdirectory.RoomDirectoryActivity
-import im.vector.app.initialSyncIdlingResource
-import im.vector.app.waitForView
-import im.vector.app.withIdlingResource
+import im.vector.app.getString
+import im.vector.app.ui.robot.ElementRobot
+import im.vector.app.ui.robot.withDeveloperMode
import org.junit.Rule
import org.junit.Test
+import org.junit.rules.RuleChain
import org.junit.runner.RunWith
-import java.lang.Thread.sleep
import java.util.UUID
/**
@@ -73,9 +39,11 @@ import java.util.UUID
class UiAllScreensSanityTest {
@get:Rule
- val activityRule = ActivityScenarioRule(MainActivity::class.java)
+ val testRule = RuleChain
+ .outerRule(ActivityScenarioRule(MainActivity::class.java))
+ .around(ScreenshotFailureRule())
- private val uiTestBase = UiTestBase()
+ private val elementRobot = ElementRobot()
// Last passing:
// 2020-11-09
@@ -85,439 +53,63 @@ class UiAllScreensSanityTest {
fun allScreensTest() {
// Create an account
val userId = "UiTest_" + UUID.randomUUID().toString()
- uiTestBase.createAccount(userId = userId)
+ elementRobot.signUp(userId)
- withIdlingResource(activityIdlingResource(HomeActivity::class.java)) {
- assertDisplayed(R.id.roomListContainer)
- closeSoftKeyboard()
+ elementRobot.settings {
+ general { crawl() }
+ notifications { crawl() }
+ preferences { crawl() }
+ voiceAndVideo()
+ ignoredUsers()
+ securityAndPrivacy { crawl() }
+ labs()
+ advancedSettings { crawl() }
+ helpAndAbout { crawl() }
}
- val activity = EspressoHelper.getCurrentActivity()!!
- val uiSession = (activity as HomeActivity).activeSessionHolder.getActiveSession()
-
- withIdlingResource(initialSyncIdlingResource(uiSession)) {
- assertDisplayed(R.id.roomListContainer)
+ elementRobot.newDirectMessage {
+ verifyQrCodeButton()
+ verifyInviteFriendsButton()
}
- assertDisplayed(R.id.bottomNavigationView)
+ elementRobot.newRoom {
+ createNewRoom {
+ crawl()
+ createRoom {
+ val message = "Hello world!"
+ postMessage(message)
+ crawl()
+ crawlMessage(message)
+ openSettings { crawl() }
+ }
+ }
+ }
- // Settings
- navigateToSettings()
+ elementRobot.withDeveloperMode {
+ settings {
+ advancedSettings { crawlDeveloperOptions() }
+ }
+ roomList {
+ openRoom(getString(R.string.room_displayname_empty_room)) {
+ val message = "Test view source"
+ postMessage(message)
+ openMessageMenu(message) {
+ viewSource()
+ }
+ }
+ }
+ }
- // Create DM
- clickOn(R.id.bottom_action_people)
- createDm()
+ elementRobot.roomList {
+ verifyCreatedRoom()
+ }
- // Create Room
- // First navigate to the other tab
- clickOn(R.id.bottom_action_rooms)
- createRoom()
-
- assertDisplayed(R.id.bottomNavigationView)
-
- // Long click on the room
- onView(withId(R.id.roomListView))
- .perform(
- actionOnItem(
- hasDescendant(withText(R.string.room_displayname_empty_room)),
- longClick()
- )
- )
- pressBack()
-
- uiTestBase.signout()
-
- // We have sent a message in a e2e room, accept to loose it
- clickOn(R.id.exitAnywayButton)
- // Dark pattern
- clickDialogNegativeButton()
+ elementRobot.signout(expectSignOutWarning = true)
// Login again on the same account
- waitUntilActivityVisible {
- assertDisplayed(R.id.loginSplashLogo)
- }
-
- uiTestBase.login(userId)
- ignoreVerification()
-
- uiTestBase.signout()
- clickDialogPositiveButton()
-
+ elementRobot.login(userId)
+ elementRobot.dismissVerificationIfPresent()
// TODO Deactivate account instead of logout?
- }
-
- private fun ignoreVerification() {
- sleep(6000)
- val activity = EspressoHelper.getCurrentActivity()!!
-
- val popup = activity.findViewById(com.tapadoo.alerter.R.id.llAlertBackground)
- activity.runOnUiThread {
- popup.performClick()
- }
-
- assertDisplayed(R.id.bottomSheetFragmentContainer)
-
- onView(isRoot()).perform(SleepViewAction.sleep(2000))
-
- clickOn(R.string.skip)
- assertDisplayed(R.string.are_you_sure)
- clickOn(R.string.skip)
- }
-
- private fun createRoom() {
- clickOn(R.id.createGroupRoomButton)
- waitUntilActivityVisible {
- assertDisplayed(R.id.publicRoomsList)
- }
- clickOn(R.string.create_new_room)
-
- // Room access bottom sheet
- clickOn(R.string.room_settings_room_access_private_title)
- pressBack()
-
- // Create
- assertListItemCount(R.id.createRoomForm, 12)
- clickListItemChild(R.id.createRoomForm, 11, R.id.form_submit_button)
-
- waitUntilActivityVisible {
- assertDisplayed(R.id.roomDetailContainer)
- }
-
- clickOn(R.id.attachmentButton)
- clickBack()
-
- // Send a message
- writeTo(R.id.composerEditText, "Hello world!")
- clickOn(R.id.sendButton)
-
- navigateToRoomSettings()
-
- // Long click on the message
- longClickOnMessageTest()
-
- // Menu
- openMenu()
- pressBack()
- clickMenu(R.id.voice_call)
- pressBack()
- clickMenu(R.id.video_call)
- pressBack()
- clickMenu(R.id.search)
- pressBack()
-
- pressBack()
- }
-
- private fun longClickOnMessageTest() {
- // Test quick reaction
- longClickOnMessage()
- // Add quick reaction
- clickOn("\uD83D\uDC4D️") // 👍
-
- sleep(1000)
-
- // Open reactions
- longClickOn("\uD83D\uDC4D️") // 👍
- pressBack()
-
- // Test add reaction
- longClickOnMessage()
- clickOn(R.string.message_add_reaction)
- // Filter
- // TODO clickMenu(R.id.search)
- // Wait for emoji to load, it's async now
- sleep(2_000)
- clickListItem(R.id.emojiRecyclerView, 4)
-
- // Test Edit mode
- longClickOnMessage()
- clickOn(R.string.edit)
- // TODO Cancel action
- writeTo(R.id.composerEditText, "Hello universe!")
- // Wait a bit for the keyboard layout to update
- sleep(30)
- clickOn(R.id.sendButton)
- // Wait for the UI to update
- sleep(1000)
- // Open edit history
- longClickOnMessage("Hello universe! (edited)")
- clickOn(R.string.message_view_edit_history)
- pressBack()
- }
-
- private fun longClickOnMessage(text: String = "Hello world!") {
- onView(withId(R.id.timelineRecyclerView))
- .perform(
- actionOnItem(
- hasDescendant(withText(text)),
- longClick()
- )
- )
- }
-
- private fun navigateToRoomSettings() {
- clickOn(R.id.roomToolbarTitleView)
- assertDisplayed(R.id.roomProfileAvatarView)
-
- // Room settings
- clickListItem(R.id.matrixProfileRecyclerView, 3)
- navigateToRoomParameters()
- pressBack()
-
- // Notifications
- clickListItem(R.id.matrixProfileRecyclerView, 5)
- pressBack()
-
- assertDisplayed(R.id.roomProfileAvatarView)
-
- // People
- clickListItem(R.id.matrixProfileRecyclerView, 7)
- assertDisplayed(R.id.inviteUsersButton)
- navigateToRoomPeople()
- // Fab
- navigateToInvite()
- pressBack()
- pressBack()
-
- assertDisplayed(R.id.roomProfileAvatarView)
-
- // Uploads
- clickListItem(R.id.matrixProfileRecyclerView, 9)
- // File tab
- clickOn(R.string.uploads_files_title)
- sleep(1000)
- pressBack()
-
- assertDisplayed(R.id.roomProfileAvatarView)
-
- // Leave
- clickListItem(R.id.matrixProfileRecyclerView, 13)
- clickDialogNegativeButton()
-
- // Advanced
- // Room addresses
- clickListItem(R.id.matrixProfileRecyclerView, 15)
- onView(isRoot()).perform(waitForView(withText(R.string.room_alias_published_alias_title)))
- pressBack()
-
- // Room permissions
- clickListItem(R.id.matrixProfileRecyclerView, 17)
- onView(isRoot()).perform(waitForView(withText(R.string.room_permissions_title)))
- clickOn(R.string.room_permissions_change_room_avatar)
- clickDialogNegativeButton()
- // Toggle
- clickOn(R.string.show_advanced)
- clickOn(R.string.hide_advanced)
- pressBack()
-
- // Menu share
- // clickMenu(R.id.roomProfileShareAction)
- // pressBack()
-
- pressBack()
- }
-
- private fun navigateToRoomParameters() {
- // Room history readability
- clickListItem(R.id.roomSettingsRecyclerView, 4)
- pressBack()
-
- // Room access
- clickListItem(R.id.roomSettingsRecyclerView, 6)
- pressBack()
- }
-
- private fun navigateToInvite() {
- assertDisplayed(R.id.inviteUsersButton)
- clickOn(R.id.inviteUsersButton)
- closeSoftKeyboard()
- pressBack()
- }
-
- private fun navigateToRoomPeople() {
- // Open first user
- clickListItem(R.id.roomSettingsRecyclerView, 1)
- sleep(1000)
- assertDisplayed(R.id.memberProfilePowerLevelView)
-
- // Verification
- clickListItem(R.id.matrixProfileRecyclerView, 1)
- clickBack()
-
- // Role
- clickListItem(R.id.matrixProfileRecyclerView, 3)
- sleep(1000)
- clickDialogNegativeButton()
- sleep(1000)
- clickBack()
- }
-
- private fun createDm() {
- clickOn(R.id.createChatRoomButton)
-
- withIdlingResource(activityIdlingResource(CreateDirectRoomActivity::class.java)) {
- onView(withId(R.id.userListRecyclerView))
- .perform(waitForView(withText(R.string.qr_code)))
- onView(withId(R.id.userListRecyclerView))
- .perform(waitForView(withText(R.string.invite_friends)))
- }
-
- closeSoftKeyboard()
- pressBack()
- pressBack()
- }
-
- private fun navigateToSettings() {
- // clickOn(R.id.groupToolbarAvatarImageView)
- openDrawer()
- clickOn(R.id.homeDrawerHeaderSettingsView)
-
- clickOn(R.string.settings_general_title)
- navigateToSettingsGeneral()
- pressBack()
-
- clickOn(R.string.settings_notifications)
- navigateToSettingsNotifications()
- pressBack()
-
- clickOn(R.string.settings_preferences)
- navigateToSettingsPreferences()
- pressBack()
-
- clickOn(R.string.preference_voice_and_video)
- pressBack()
-
- clickOn(R.string.settings_ignored_users)
- pressBack()
-
- clickOn(R.string.settings_security_and_privacy)
- navigateToSettingsSecurity()
- pressBack()
-
- clickOn(R.string.room_settings_labs_pref_title)
- pressBack()
-
- clickOn(R.string.settings_advanced_settings)
- navigateToSettingsAdvanced()
- pressBack()
-
- clickOn(R.string.preference_root_help_about)
- navigateToSettingsHelp()
- pressBack()
-
- pressBack()
- }
-
- private fun navigateToSettingsHelp() {
- /*
- clickOn(R.string.settings_app_info_link_title)
- Cannot go back...
- pressBack()
- clickOn(R.string.settings_copyright)
- pressBack()
- clickOn(R.string.settings_app_term_conditions)
- pressBack()
- clickOn(R.string.settings_privacy_policy)
- pressBack()
- */
- clickOn(R.string.settings_third_party_notices)
- clickDialogPositiveButton()
- }
-
- private fun navigateToSettingsAdvanced() {
- clickOnPreference(R.string.settings_notifications_targets)
- pressBack()
-
- clickOnPreference(R.string.settings_push_rules)
- pressBack()
-
- /* TODO P2 test developer screens
- // Enable developer mode
- clickOnSwitchPreference("SETTINGS_DEVELOPER_MODE_PREFERENCE_KEY")
-
- clickOnPreference(R.string.settings_account_data)
- clickOn("m.push_rules")
- pressBack()
- pressBack()
- clickOnPreference(R.string.settings_key_requests)
- pressBack()
-
- // Disable developer mode
- clickOnSwitchPreference("SETTINGS_DEVELOPER_MODE_PREFERENCE_KEY")
- */
- }
-
- private fun navigateToSettingsSecurity() {
- clickOnPreference(R.string.settings_active_sessions_show_all)
- pressBack()
-
- clickOnPreference(R.string.encryption_message_recovery)
- // TODO go deeper here
- pressBack()
- /* Cannot exit
- clickOnPreference(R.string.encryption_export_e2e_room_keys)
- pressBack()
- */
- }
-
- private fun navigateToSettingsPreferences() {
- clickOn(R.string.settings_interface_language)
- onView(isRoot())
- .perform(waitForView(withText("Dansk (Danmark)")))
- pressBack()
- clickOn(R.string.settings_theme)
- clickDialogNegativeButton()
- clickOn(R.string.font_size)
- clickDialogNegativeButton()
- }
-
- private fun navigateToSettingsNotifications() {
- if (BuildConfig.USE_NOTIFICATION_SETTINGS_V2) {
- clickOn(R.string.settings_notification_default)
- pressBack()
- clickOn(R.string.settings_notification_mentions_and_keywords)
- // TODO Test adding a keyword?
- pressBack()
- clickOn(R.string.settings_notification_other)
- pressBack()
- } else {
- clickOn(R.string.settings_notification_advanced)
- pressBack()
- }
- /*
- clickOn(R.string.settings_noisy_notifications_preferences)
- TODO Cannot go back
- pressBack()
- clickOn(R.string.settings_silent_notifications_preferences)
- pressBack()
- clickOn(R.string.settings_call_notifications_preferences)
- pressBack()
- */
- clickOnPreference(R.string.settings_notification_troubleshoot)
- pressBack()
- }
-
- private fun navigateToSettingsGeneral() {
- clickOn(R.string.settings_profile_picture)
- clickDialogPositiveButton()
- clickOn(R.string.settings_display_name)
- clickDialogNegativeButton()
- clickOn(R.string.settings_password)
- clickDialogNegativeButton()
- clickOn(R.string.settings_emails_and_phone_numbers_title)
- pressBack()
- clickOn(R.string.settings_discovery_manage)
- clickOn(R.string.add_identity_server)
- pressBack()
- pressBack()
- // Homeserver
- clickOnPreference(R.string.settings_home_server)
- pressBack()
- // Identity server
- clickOnPreference(R.string.settings_identity_server)
- pressBack()
- // Deactivate account
- clickOnPreference(R.string.settings_deactivate_my_account)
- pressBack()
+ elementRobot.signout(expectSignOutWarning = false)
}
}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/CreateNewRoomRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/CreateNewRoomRobot.kt
new file mode 100644
index 0000000000..505dfb33e9
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/CreateNewRoomRobot.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import com.adevinta.android.barista.assertion.BaristaListAssertions
+import com.adevinta.android.barista.interaction.BaristaClickInteractions
+import com.adevinta.android.barista.interaction.BaristaListInteractions
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilActivityVisible
+import im.vector.app.espresso.tools.waitUntilViewVisible
+import im.vector.app.features.home.room.detail.RoomDetailActivity
+
+class CreateNewRoomRobot(
+ var createdRoom: Boolean = false
+) {
+
+ fun createRoom(block: RoomDetailRobot.() -> Unit) {
+ createdRoom = true
+ BaristaListAssertions.assertListItemCount(R.id.createRoomForm, 12)
+ BaristaListInteractions.clickListItemChild(R.id.createRoomForm, 11, R.id.form_submit_button)
+ waitUntilActivityVisible {
+ waitUntilViewVisible(withId(R.id.composerEditText))
+ }
+ block(RoomDetailRobot())
+ pressBack()
+ }
+
+ fun crawl() {
+ // Room access bottom sheet
+ BaristaClickInteractions.clickOn(R.string.room_settings_room_access_private_title)
+ pressBack()
+ }
+}
diff --git a/vector/src/main/java/im/vector/app/features/call/telecom/TelecomUtils.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/DialogRobot.kt
similarity index 55%
rename from vector/src/main/java/im/vector/app/features/call/telecom/TelecomUtils.kt
rename to vector/src/androidTest/java/im/vector/app/ui/robot/DialogRobot.kt
index 819a1f6c0a..14c2d6284e 100644
--- a/vector/src/main/java/im/vector/app/features/call/telecom/TelecomUtils.kt
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/DialogRobot.kt
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2020 New Vector Ltd
+ * Copyright (c) 2021 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.
@@ -14,17 +14,16 @@
* limitations under the License.
*/
-package im.vector.app.features.call.telecom
+package im.vector.app.ui.robot
-import android.content.Context
-import android.telephony.TelephonyManager
-import androidx.core.content.getSystemService
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
-object TelecomUtils {
+class DialogRobot(
+ var returnedToPreviousScreen: Boolean = false
+) {
- fun isLineBusy(context: Context): Boolean {
- val telephonyManager = context.getSystemService()
- ?: return false
- return telephonyManager.callState != TelephonyManager.CALL_STATE_IDLE
+ fun negativeAction() {
+ clickDialogNegativeButton()
+ returnedToPreviousScreen = true
}
}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/ElementRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/ElementRobot.kt
new file mode 100644
index 0000000000..a3bc5b26fc
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/ElementRobot.kt
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import android.view.View
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.matcher.ViewMatchers
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import com.adevinta.android.barista.assertion.BaristaVisibilityAssertions.assertDisplayed
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogPositiveButton
+import com.adevinta.android.barista.interaction.BaristaDrawerInteractions.openDrawer
+import im.vector.app.EspressoHelper
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilActivityVisible
+import im.vector.app.espresso.tools.waitUntilViewVisible
+import im.vector.app.features.createdirect.CreateDirectRoomActivity
+import im.vector.app.features.home.HomeActivity
+import im.vector.app.features.login.LoginActivity
+import im.vector.app.initialSyncIdlingResource
+import im.vector.app.ui.robot.settings.SettingsRobot
+import im.vector.app.withIdlingResource
+import timber.log.Timber
+
+class ElementRobot {
+
+ fun signUp(userId: String) {
+ val onboardingRobot = OnboardingRobot()
+ onboardingRobot.createAccount(userId = userId)
+ waitForHome()
+ }
+
+ fun login(userId: String) {
+ val onboardingRobot = OnboardingRobot()
+ onboardingRobot.login(userId = userId)
+ waitForHome()
+ }
+
+ private fun waitForHome() {
+ waitUntilActivityVisible {
+ waitUntilViewVisible(withId(R.id.roomListContainer))
+ }
+ val activity = EspressoHelper.getCurrentActivity()!!
+ val uiSession = (activity as HomeActivity).activeSessionHolder.getActiveSession()
+ withIdlingResource(initialSyncIdlingResource(uiSession)) {
+ waitUntilViewVisible(withId(R.id.bottomNavigationView))
+ }
+ }
+
+ fun settings(block: SettingsRobot.() -> Unit) {
+ openDrawer()
+ clickOn(R.id.homeDrawerHeaderSettingsView)
+ block(SettingsRobot())
+ pressBack()
+ waitUntilViewVisible(withId(R.id.bottomNavigationView))
+ }
+
+ fun newDirectMessage(block: NewDirectMessageRobot.() -> Unit) {
+ clickOn(R.id.bottom_action_people)
+ clickOn(R.id.createChatRoomButton)
+ waitUntilActivityVisible {
+ waitUntilViewVisible(withId(R.id.userListSearch))
+ }
+ // close keyboard
+ pressBack()
+ block(NewDirectMessageRobot())
+ pressBack()
+ waitUntilViewVisible(withId(R.id.bottomNavigationView))
+ }
+
+ fun newRoom(block: NewRoomRobot.() -> Unit) {
+ clickOn(R.id.bottom_action_rooms)
+ RoomListRobot().newRoom { block() }
+ waitUntilViewVisible(withId(R.id.bottomNavigationView))
+ }
+
+ fun roomList(block: RoomListRobot.() -> Unit) {
+ clickOn(R.id.bottom_action_rooms)
+ block(RoomListRobot())
+ waitUntilViewVisible(withId(R.id.bottomNavigationView))
+ }
+
+ fun signout(expectSignOutWarning: Boolean) {
+ clickOn(R.id.groupToolbarAvatarImageView)
+ clickOn(R.id.homeDrawerHeaderSignoutView)
+
+ val isShowingSignOutWarning = kotlin.runCatching {
+ waitUntilViewVisible(withId(R.id.exitAnywayButton))
+ }.isSuccess
+
+ if (expectSignOutWarning != isShowingSignOutWarning) {
+ Timber.w("Unexpected sign out flow, expected warning to be: ${expectSignOutWarning.toWarningType()} but was ${isShowingSignOutWarning.toWarningType()}")
+ }
+
+ if (isShowingSignOutWarning) {
+ // We have sent a message in a e2e room, accept to loose it
+ clickOn(R.id.exitAnywayButton)
+ // Dark pattern
+ waitUntilViewVisible(withId(android.R.id.button2))
+ clickDialogNegativeButton()
+ } else {
+ waitUntilViewVisible(withId(android.R.id.button1))
+ clickDialogPositiveButton()
+ }
+
+ waitUntilActivityVisible {
+ assertDisplayed(R.id.loginSplashLogo)
+ }
+ }
+
+ fun dismissVerificationIfPresent() {
+ kotlin.runCatching {
+ Thread.sleep(6000)
+ val activity = EspressoHelper.getCurrentActivity()!!
+ val popup = activity.findViewById(com.tapadoo.alerter.R.id.llAlertBackground)!!
+ activity.runOnUiThread { popup.performClick() }
+
+ waitUntilViewVisible(withId(R.id.bottomSheetFragmentContainer))
+ waitUntilViewVisible(ViewMatchers.withText(R.string.skip))
+ clickOn(R.string.skip)
+ assertDisplayed(R.string.are_you_sure)
+ clickOn(R.string.skip)
+ waitUntilViewVisible(withId(R.id.bottomSheetFragmentContainer))
+ }.onFailure { Timber.w("Verification popup missing", it) }
+ }
+}
+
+private fun Boolean.toWarningType() = if (this) "shown" else "skipped"
+
+fun ElementRobot.withDeveloperMode(block: ElementRobot.() -> Unit) {
+ settings { toggleDeveloperMode() }
+ block()
+ settings { toggleDeveloperMode() }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/MessageMenuRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/MessageMenuRobot.kt
new file mode 100644
index 0000000000..fd579c0d9f
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/MessageMenuRobot.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.test.espresso.Espresso.pressBack
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaListInteractions.clickListItem
+import im.vector.app.R
+import java.lang.Thread.sleep
+
+class MessageMenuRobot(
+ var autoClosed: Boolean = false
+) {
+
+ fun viewSource() {
+ clickOn(R.string.view_source)
+ // wait for library
+ sleep(1000)
+ pressBack()
+ autoClosed = true
+ }
+
+ fun editHistory() {
+ clickOn(R.string.message_view_edit_history)
+ pressBack()
+ autoClosed = true
+ }
+
+ fun addQuickReaction(quickReaction: String) {
+ clickOn(quickReaction)
+ autoClosed = true
+ }
+
+ fun addReactionFromEmojiPicker() {
+ clickOn(R.string.message_add_reaction)
+ // Wait for emoji to load, it's async now
+ sleep(2000)
+ clickListItem(R.id.emojiRecyclerView, 4)
+ autoClosed = true
+ }
+
+ fun edit() {
+ clickOn(R.string.edit)
+ autoClosed = true
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/NewDirectMessageRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/NewDirectMessageRobot.kt
new file mode 100644
index 0000000000..34c43c73f7
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/NewDirectMessageRobot.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.test.espresso.Espresso
+import androidx.test.espresso.matcher.ViewMatchers
+import im.vector.app.R
+import im.vector.app.waitForView
+
+class NewDirectMessageRobot {
+
+ fun verifyQrCodeButton() {
+ Espresso.onView(ViewMatchers.withId(R.id.userListRecyclerView))
+ .perform(waitForView(ViewMatchers.withText(R.string.qr_code)))
+ }
+
+ fun verifyInviteFriendsButton() {
+ Espresso.onView(ViewMatchers.withId(R.id.userListRecyclerView))
+ .perform(waitForView(ViewMatchers.withText(R.string.invite_friends)))
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/NewRoomRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/NewRoomRobot.kt
new file mode 100644
index 0000000000..09ff1162c0
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/NewRoomRobot.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilViewVisible
+
+class NewRoomRobot(
+ var createdRoom: Boolean = false
+) {
+
+ fun createNewRoom(block: CreateNewRoomRobot.() -> Unit) {
+ clickOn(R.string.create_new_room)
+ waitUntilViewVisible(withId(R.id.createRoomForm))
+ val createNewRoomRobot = CreateNewRoomRobot()
+ block(createNewRoomRobot)
+ createdRoom = createNewRoomRobot.createdRoom
+ if (!createNewRoomRobot.createdRoom) {
+ pressBack()
+ }
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/UiTestBase.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/OnboardingRobot.kt
similarity index 88%
rename from vector/src/androidTest/java/im/vector/app/ui/UiTestBase.kt
rename to vector/src/androidTest/java/im/vector/app/ui/robot/OnboardingRobot.kt
index 2cef326501..fef5d4a1a2 100644
--- a/vector/src/androidTest/java/im/vector/app/ui/UiTestBase.kt
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/OnboardingRobot.kt
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-package im.vector.app.ui
+package im.vector.app.ui.robot
import androidx.test.espresso.Espresso.closeSoftKeyboard
import androidx.test.espresso.Espresso.onView
@@ -26,11 +26,10 @@ import com.adevinta.android.barista.assertion.BaristaVisibilityAssertions.assert
import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
import com.adevinta.android.barista.interaction.BaristaEditTextInteractions.writeTo
import im.vector.app.R
-import im.vector.app.espresso.tools.waitUntilActivityVisible
-import im.vector.app.features.home.HomeActivity
import im.vector.app.waitForView
-class UiTestBase {
+class OnboardingRobot {
+
fun createAccount(userId: String, password: String = "password", homeServerUrl: String = "http://10.0.2.2:8080") {
initSession(true, userId, password, homeServerUrl)
}
@@ -76,15 +75,5 @@ class UiTestBase {
closeSoftKeyboard()
clickOn(R.id.loginSubmit)
-
- // Wait
- waitUntilActivityVisible {
- assertDisplayed(R.id.homeDetailFragmentContainer)
- }
- }
-
- fun signout() {
- clickOn(R.id.groupToolbarAvatarImageView)
- clickOn(R.id.homeDrawerHeaderSignoutView)
}
}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/RoomDetailRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomDetailRobot.kt
new file mode 100644
index 0000000000..24fe5adf64
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomDetailRobot.kt
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.recyclerview.widget.RecyclerView
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.contrib.RecyclerViewActions
+import androidx.test.espresso.matcher.ViewMatchers
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import com.adevinta.android.barista.interaction.BaristaClickInteractions
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.longClickOn
+import com.adevinta.android.barista.interaction.BaristaEditTextInteractions.writeTo
+import com.adevinta.android.barista.interaction.BaristaMenuClickInteractions.clickMenu
+import com.adevinta.android.barista.interaction.BaristaMenuClickInteractions.openMenu
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilViewVisible
+import im.vector.app.features.home.room.detail.timeline.action.MessageActionsBottomSheet
+import im.vector.app.features.reactions.data.EmojiDataSource
+import im.vector.app.interactWithSheet
+import im.vector.app.waitForView
+import java.lang.Thread.sleep
+
+class RoomDetailRobot {
+
+ fun postMessage(content: String) {
+ writeTo(R.id.composerEditText, content)
+ waitUntilViewVisible(withId(R.id.sendButton))
+ clickOn(R.id.sendButton)
+ waitUntilViewVisible(withText(content))
+ }
+
+ fun crawl() {
+ clickOn(R.id.attachmentButton)
+ BaristaClickInteractions.clickBack()
+
+ // Menu
+ openMenu()
+ pressBack()
+ clickMenu(R.id.voice_call)
+ pressBack()
+ clickMenu(R.id.video_call)
+ pressBack()
+ clickMenu(R.id.search)
+ pressBack()
+ }
+
+ fun crawlMessage(message: String) {
+ // Test quick reaction
+ val quickReaction = EmojiDataSource.quickEmojis[0] // 👍
+ openMessageMenu(message) {
+ addQuickReaction(quickReaction)
+ }
+ // Open reactions
+ longClickOn(quickReaction)
+ // wait for bottom sheet
+ pressBack()
+ // Test add reaction
+ openMessageMenu(message) {
+ addReactionFromEmojiPicker()
+ }
+ // Test Edit mode
+ openMessageMenu(message) {
+ edit()
+ }
+ // TODO Cancel action
+ writeTo(R.id.composerEditText, "Hello universe!")
+ // Wait a bit for the keyboard layout to update
+ waitUntilViewVisible(withId(R.id.sendButton))
+ clickOn(R.id.sendButton)
+ // Wait for the UI to update
+ waitUntilViewVisible(withText("Hello universe! (edited)"))
+ // Open edit history
+ openMessageMenu("Hello universe! (edited)") {
+ editHistory()
+ }
+ }
+
+ fun openMessageMenu(message: String, block: MessageMenuRobot.() -> Unit) {
+ onView(withId(R.id.timelineRecyclerView))
+ .perform(
+ RecyclerViewActions.actionOnItem(
+ ViewMatchers.hasDescendant(ViewMatchers.withText(message)),
+ ViewActions.longClick()
+ )
+ )
+ interactWithSheet(contentMatcher = withId(R.id.bottomSheetRecyclerView)) {
+ val messageMenuRobot = MessageMenuRobot()
+ block(messageMenuRobot)
+ if (!messageMenuRobot.autoClosed) {
+ pressBack()
+ }
+ }
+ }
+
+ fun openSettings(block: RoomSettingsRobot.() -> Unit) {
+ clickOn(R.id.roomToolbarTitleView)
+ waitForView(withId(R.id.roomProfileAvatarView))
+ sleep(1000)
+ block(RoomSettingsRobot())
+ pressBack()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/RoomListRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomListRobot.kt
new file mode 100644
index 0000000000..dc07f06202
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomListRobot.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.recyclerview.widget.RecyclerView
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.contrib.RecyclerViewActions
+import androidx.test.espresso.matcher.ViewMatchers
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import com.adevinta.android.barista.assertion.BaristaVisibilityAssertions
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilActivityVisible
+import im.vector.app.features.roomdirectory.RoomDirectoryActivity
+
+class RoomListRobot {
+
+ fun openRoom(roomName: String, block: RoomDetailRobot.() -> Unit) {
+ clickOn(roomName)
+ block(RoomDetailRobot())
+ pressBack()
+ }
+
+ fun verifyCreatedRoom() {
+ onView(ViewMatchers.withId(R.id.roomListView))
+ .perform(
+ RecyclerViewActions.actionOnItem(
+ ViewMatchers.hasDescendant(withText(R.string.room_displayname_empty_room)),
+ ViewActions.longClick()
+ )
+ )
+ pressBack()
+ }
+
+ fun newRoom(block: NewRoomRobot.() -> Unit) {
+ clickOn(R.id.createGroupRoomButton)
+ waitUntilActivityVisible {
+ BaristaVisibilityAssertions.assertDisplayed(R.id.publicRoomsList)
+ }
+ val newRoomRobot = NewRoomRobot()
+ block(newRoomRobot)
+ if (!newRoomRobot.createdRoom) {
+ pressBack()
+ }
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/RoomSettingsRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomSettingsRobot.kt
new file mode 100644
index 0000000000..15186fe0c8
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/RoomSettingsRobot.kt
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot
+
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import com.adevinta.android.barista.assertion.BaristaVisibilityAssertions.assertDisplayed
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
+import com.adevinta.android.barista.interaction.BaristaListInteractions.clickListItem
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilActivityVisible
+import im.vector.app.espresso.tools.waitUntilViewVisible
+import im.vector.app.features.roommemberprofile.RoomMemberProfileActivity
+
+class RoomSettingsRobot {
+
+ fun crawl() {
+ // Room settings
+ clickListItem(R.id.matrixProfileRecyclerView, 3)
+ navigateToRoomParameters()
+ pressBack()
+
+ // Notifications
+ clickListItem(R.id.matrixProfileRecyclerView, 5)
+ pressBack()
+
+ assertDisplayed(R.id.roomProfileAvatarView)
+
+ // People
+ clickListItem(R.id.matrixProfileRecyclerView, 7)
+ assertDisplayed(R.id.inviteUsersButton)
+ navigateToRoomPeople()
+ // Fab
+ navigateToInvite()
+ pressBack()
+ pressBack()
+
+ assertDisplayed(R.id.roomProfileAvatarView)
+
+ // Uploads
+ clickListItem(R.id.matrixProfileRecyclerView, 9)
+ // File tab
+ clickOn(R.string.uploads_files_title)
+ waitUntilViewVisible(withText(R.string.uploads_media_title))
+ pressBack()
+ waitUntilViewVisible(withId(R.id.matrixProfileRecyclerView))
+
+ assertDisplayed(R.id.roomProfileAvatarView)
+
+ // Leave
+ leaveRoom {
+ negativeAction()
+ }
+
+ // Advanced
+ // Room addresses
+
+ clickListItem(R.id.matrixProfileRecyclerView, 15)
+ waitUntilViewVisible(withText(R.string.room_alias_published_alias_title))
+ pressBack()
+
+ // Room permissions
+ clickListItem(R.id.matrixProfileRecyclerView, 17)
+ waitUntilViewVisible(withText(R.string.room_permissions_title))
+ clickOn(R.string.room_permissions_change_room_avatar)
+ waitUntilViewVisible(withId(android.R.id.button2))
+ clickDialogNegativeButton()
+ waitUntilViewVisible(withText(R.string.room_permissions_title))
+ // Toggle
+ clickOn(R.string.show_advanced)
+ clickOn(R.string.hide_advanced)
+ pressBack()
+
+ // Menu share
+ // clickMenu(R.id.roomProfileShareAction)
+ // pressBack()
+ }
+
+ private fun leaveRoom(block: DialogRobot.() -> Unit) {
+ clickListItem(R.id.matrixProfileRecyclerView, 13)
+ waitUntilViewVisible(withId(android.R.id.button2))
+ val dialogRobot = DialogRobot()
+ block(dialogRobot)
+ if (dialogRobot.returnedToPreviousScreen) {
+ waitUntilViewVisible(withId(R.id.matrixProfileRecyclerView))
+ }
+ }
+
+ private fun navigateToRoomParameters() {
+ // Room history readability
+ clickListItem(R.id.roomSettingsRecyclerView, 4)
+ pressBack()
+
+ // Room access
+ clickListItem(R.id.roomSettingsRecyclerView, 6)
+ pressBack()
+ }
+
+ private fun navigateToInvite() {
+ assertDisplayed(R.id.inviteUsersButton)
+ clickOn(R.id.inviteUsersButton)
+ ViewActions.closeSoftKeyboard()
+ pressBack()
+ }
+
+ private fun navigateToRoomPeople() {
+ // Open first user
+ clickListItem(R.id.roomSettingsRecyclerView, 1)
+ waitUntilActivityVisible {
+ waitUntilViewVisible(withId(R.id.memberProfilePowerLevelView))
+ }
+
+ // Verification
+ clickListItem(R.id.matrixProfileRecyclerView, 1)
+ waitUntilViewVisible(withId(R.id.bottomSheetRecyclerView))
+ pressBack()
+ waitUntilViewVisible(withId(R.id.matrixProfileRecyclerView))
+
+ // Role
+ clickListItem(R.id.matrixProfileRecyclerView, 3)
+ waitUntilViewVisible(withId(android.R.id.button2))
+ clickDialogNegativeButton()
+ waitUntilViewVisible(withId(R.id.matrixProfileRecyclerView))
+ pressBack()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsAdvancedRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsAdvancedRobot.kt
new file mode 100644
index 0000000000..4aeb8903dd
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsAdvancedRobot.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import im.vector.app.R
+import im.vector.app.espresso.tools.clickOnPreference
+import im.vector.app.espresso.tools.waitUntilViewVisible
+
+class SettingsAdvancedRobot {
+
+ fun crawl() {
+ clickOnPreference(R.string.settings_notifications_targets)
+ pressBack()
+
+ clickOnPreference(R.string.settings_push_rules)
+ pressBack()
+ }
+
+ fun toggleDeveloperMode() {
+ clickOn(R.string.settings_developer_mode_summary)
+ }
+
+ fun crawlDeveloperOptions() {
+ clickOnPreference(R.string.settings_account_data)
+ waitUntilViewVisible(withText("m.push_rules"))
+ clickOn("m.push_rules")
+ pressBack()
+ pressBack()
+ clickOnPreference(R.string.settings_key_requests)
+ pressBack()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsGeneralRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsGeneralRobot.kt
new file mode 100644
index 0000000000..9082eaa889
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsGeneralRobot.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import androidx.test.espresso.Espresso.pressBack
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogPositiveButton
+import im.vector.app.R
+import im.vector.app.espresso.tools.clickOnPreference
+
+class SettingsGeneralRobot {
+
+ fun crawl() {
+ clickOn(R.string.settings_profile_picture)
+ clickDialogPositiveButton()
+ clickOn(R.string.settings_display_name)
+ clickDialogNegativeButton()
+ clickOn(R.string.settings_password)
+ clickDialogNegativeButton()
+ clickOn(R.string.settings_emails_and_phone_numbers_title)
+ pressBack()
+ clickOn(R.string.settings_discovery_manage)
+ clickOn(R.string.add_identity_server)
+ pressBack()
+ pressBack()
+ // Homeserver
+ clickOnPreference(R.string.settings_home_server)
+ pressBack()
+ // Identity server
+ clickOnPreference(R.string.settings_identity_server)
+ pressBack()
+ // Deactivate account
+ clickOnPreference(R.string.settings_deactivate_my_account)
+ pressBack()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsHelpRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsHelpRobot.kt
new file mode 100644
index 0000000000..75f610d016
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsHelpRobot.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogPositiveButton
+import im.vector.app.R
+
+class SettingsHelpRobot {
+
+ fun crawl() {
+ /*
+ clickOn(R.string.settings_app_info_link_title)
+ Cannot go back...
+ pressBack()
+ clickOn(R.string.settings_copyright)
+ pressBack()
+ clickOn(R.string.settings_app_term_conditions)
+ pressBack()
+ clickOn(R.string.settings_privacy_policy)
+ pressBack()
+ */
+ clickOn(R.string.settings_third_party_notices)
+ clickDialogPositiveButton()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsNotificationsRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsNotificationsRobot.kt
new file mode 100644
index 0000000000..448552ba8e
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsNotificationsRobot.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import androidx.test.espresso.Espresso.pressBack
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import im.vector.app.BuildConfig
+import im.vector.app.R
+import im.vector.app.espresso.tools.clickOnPreference
+
+class SettingsNotificationsRobot {
+
+ fun crawl() {
+ if (BuildConfig.USE_NOTIFICATION_SETTINGS_V2) {
+ clickOn(R.string.settings_notification_default)
+ pressBack()
+ clickOn(R.string.settings_notification_mentions_and_keywords)
+ // TODO Test adding a keyword?
+ pressBack()
+ clickOn(R.string.settings_notification_other)
+ pressBack()
+ } else {
+ clickOn(R.string.settings_notification_advanced)
+ pressBack()
+ }
+ /*
+ clickOn(R.string.settings_noisy_notifications_preferences)
+ TODO Cannot go back
+ pressBack()
+ clickOn(R.string.settings_silent_notifications_preferences)
+ pressBack()
+ clickOn(R.string.settings_call_notifications_preferences)
+ pressBack()
+ */
+ clickOnPreference(R.string.settings_notification_troubleshoot)
+ pressBack()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsPreferencesRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsPreferencesRobot.kt
new file mode 100644
index 0000000000..438bbac5a5
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsPreferencesRobot.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import androidx.test.espresso.Espresso.pressBack
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import com.adevinta.android.barista.interaction.BaristaClickInteractions.clickOn
+import com.adevinta.android.barista.interaction.BaristaDialogInteractions.clickDialogNegativeButton
+import im.vector.app.R
+import im.vector.app.espresso.tools.waitUntilViewVisible
+
+class SettingsPreferencesRobot {
+
+ fun crawl() {
+ clickOn(R.string.settings_interface_language)
+ waitUntilViewVisible(withText("Dansk (Danmark)"))
+ pressBack()
+ clickOn(R.string.settings_theme)
+ clickDialogNegativeButton()
+ clickOn(R.string.font_size)
+ clickDialogNegativeButton()
+ }
+}
diff --git a/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsRobot.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsRobot.kt
new file mode 100644
index 0000000000..a9c053f6c3
--- /dev/null
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsRobot.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2021 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.app.ui.robot.settings
+
+import im.vector.app.R
+import im.vector.app.clickOnAndGoBack
+
+class SettingsRobot {
+
+ fun toggleDeveloperMode() {
+ advancedSettings {
+ toggleDeveloperMode()
+ }
+ }
+
+ fun general(block: SettingsGeneralRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.settings_general_title) { block(SettingsGeneralRobot()) }
+ }
+
+ fun notifications(block: SettingsNotificationsRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.settings_notifications) { block(SettingsNotificationsRobot()) }
+ }
+
+ fun preferences(block: SettingsPreferencesRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.settings_preferences) { block(SettingsPreferencesRobot()) }
+ }
+
+ fun voiceAndVideo(block: () -> Unit = {}) {
+ clickOnAndGoBack(R.string.preference_voice_and_video) { block() }
+ }
+
+ fun ignoredUsers(block: () -> Unit = {}) {
+ clickOnAndGoBack(R.string.settings_ignored_users) { block() }
+ }
+
+ fun securityAndPrivacy(block: SettingsSecurityRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.settings_security_and_privacy) { block(SettingsSecurityRobot()) }
+ }
+
+ fun labs(block: () -> Unit = {}) {
+ clickOnAndGoBack(R.string.room_settings_labs_pref_title) { block() }
+ }
+
+ fun advancedSettings(block: SettingsAdvancedRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.settings_advanced_settings) {
+ block(SettingsAdvancedRobot())
+ }
+ }
+
+ fun helpAndAbout(block: SettingsHelpRobot.() -> Unit) {
+ clickOnAndGoBack(R.string.preference_root_help_about) { block(SettingsHelpRobot()) }
+ }
+}
diff --git a/vector/src/test/java/im/vector/app/test/InstantRxRule.kt b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsSecurityRobot.kt
similarity index 51%
rename from vector/src/test/java/im/vector/app/test/InstantRxRule.kt
rename to vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsSecurityRobot.kt
index 1145cb7dd1..f2607bbc1c 100644
--- a/vector/src/test/java/im/vector/app/test/InstantRxRule.kt
+++ b/vector/src/androidTest/java/im/vector/app/ui/robot/settings/SettingsSecurityRobot.kt
@@ -14,19 +14,24 @@
* limitations under the License.
*/
-package im.vector.app.test
+package im.vector.app.ui.robot.settings
-import io.reactivex.android.plugins.RxAndroidPlugins
-import io.reactivex.plugins.RxJavaPlugins
-import io.reactivex.schedulers.Schedulers
-import org.junit.rules.TestRule
-import org.junit.runner.Description
-import org.junit.runners.model.Statement
+import androidx.test.espresso.Espresso
+import im.vector.app.R
+import im.vector.app.espresso.tools.clickOnPreference
-class InstantRxRule : TestRule {
- override fun apply(base: Statement, description: Description?): Statement {
- RxJavaPlugins.setInitNewThreadSchedulerHandler { Schedulers.trampoline() }
- RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() }
- return base
+class SettingsSecurityRobot {
+
+ fun crawl() {
+ clickOnPreference(R.string.settings_active_sessions_show_all)
+ Espresso.pressBack()
+
+ clickOnPreference(R.string.encryption_message_recovery)
+ // TODO go deeper here
+ Espresso.pressBack()
+ /* Cannot exit
+ clickOnPreference(R.string.encryption_export_e2e_room_keys)
+ pressBack()
+ */
}
}
diff --git a/vector/src/fdroid/AndroidManifest.xml b/vector/src/fdroid/AndroidManifest.xml
index 022b08f16d..ea9fa023ab 100644
--- a/vector/src/fdroid/AndroidManifest.xml
+++ b/vector/src/fdroid/AndroidManifest.xml
@@ -14,7 +14,9 @@
-
+
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/receiver/AlarmSyncBroadcastReceiver.kt b/vector/src/fdroid/java/im/vector/app/fdroid/receiver/AlarmSyncBroadcastReceiver.kt
index 0f375561b2..c1fda2d404 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/receiver/AlarmSyncBroadcastReceiver.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/receiver/AlarmSyncBroadcastReceiver.kt
@@ -25,6 +25,7 @@ import android.os.Build
import androidx.core.content.ContextCompat
import androidx.core.content.getSystemService
import im.vector.app.core.extensions.singletonEntryPoint
+import im.vector.app.core.platform.PendingIntentCompat
import im.vector.app.core.services.VectorSyncService
import org.matrix.android.sdk.internal.session.sync.job.SyncService
import timber.log.Timber
@@ -67,7 +68,12 @@ class AlarmSyncBroadcastReceiver : BroadcastReceiver() {
putExtra(SyncService.EXTRA_SESSION_ID, sessionId)
putExtra(SyncService.EXTRA_PERIODIC, true)
}
- val pIntent = PendingIntent.getBroadcast(context, REQUEST_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT)
+ val pIntent = PendingIntent.getBroadcast(
+ context,
+ REQUEST_CODE,
+ intent,
+ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntentCompat.FLAG_IMMUTABLE
+ )
val firstMillis = System.currentTimeMillis() + delayInSeconds * 1000L
val alarmMgr = context.getSystemService()!!
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -80,7 +86,12 @@ class AlarmSyncBroadcastReceiver : BroadcastReceiver() {
fun cancelAlarm(context: Context) {
Timber.v("## Sync: Cancel alarm for background sync")
val intent = Intent(context, AlarmSyncBroadcastReceiver::class.java)
- val pIntent = PendingIntent.getBroadcast(context, REQUEST_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT)
+ val pIntent = PendingIntent.getBroadcast(
+ context,
+ REQUEST_CODE,
+ intent,
+ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntentCompat.FLAG_IMMUTABLE
+ )
val alarmMgr = context.getSystemService()!!
alarmMgr.cancel(pIntent)
diff --git a/vector/src/gplay/AndroidManifest.xml b/vector/src/gplay/AndroidManifest.xml
index d849d5fb2d..f541eebd83 100755
--- a/vector/src/gplay/AndroidManifest.xml
+++ b/vector/src/gplay/AndroidManifest.xml
@@ -9,7 +9,9 @@
android:name="firebase_analytics_collection_deactivated"
android:value="true" />
-
+
diff --git a/vector/src/gplay/java/im/vector/app/gplay/push/fcm/VectorFirebaseMessagingService.kt b/vector/src/gplay/java/im/vector/app/gplay/push/fcm/VectorFirebaseMessagingService.kt
index 63d50d4f97..e323506e9f 100755
--- a/vector/src/gplay/java/im/vector/app/gplay/push/fcm/VectorFirebaseMessagingService.kt
+++ b/vector/src/gplay/java/im/vector/app/gplay/push/fcm/VectorFirebaseMessagingService.kt
@@ -201,8 +201,7 @@ class VectorFirebaseMessagingService : FirebaseMessagingService() {
resolvedEvent
?.also { Timber.tag(loggerTag.value).d("Fast lane: notify drawer") }
?.let {
- notificationDrawerManager.onNotifiableEventReceived(it)
- notificationDrawerManager.refreshNotificationDrawer()
+ notificationDrawerManager.updateEvents { it.onNotifiableEventReceived(resolvedEvent) }
}
}
}
diff --git a/vector/src/main/AndroidManifest.xml b/vector/src/main/AndroidManifest.xml
index 376e0e869a..e5d4753235 100644
--- a/vector/src/main/AndroidManifest.xml
+++ b/vector/src/main/AndroidManifest.xml
@@ -4,7 +4,10 @@
package="im.vector.app">
-
+
+
@@ -339,6 +342,7 @@
+
@@ -417,6 +421,22 @@
android:name="android.support.FILE_PROVIDER_PATHS"
android:resource="@xml/sdk_provider_paths" />
+
+
+
+
+
+
diff --git a/vector/src/main/assets/open_source_licenses.html b/vector/src/main/assets/open_source_licenses.html
index 19daf3359b..529b7da2f1 100755
--- a/vector/src/main/assets/open_source_licenses.html
+++ b/vector/src/main/assets/open_source_licenses.html
@@ -279,25 +279,9 @@ SOFTWARE.
Copyright 2012 The Dagger Authors
- rxkotlin
+ FlowBinding
- Copyright io.reactivex.
-
-
- rxandroid
-
- Copyright io.reactivex.
-
-
- rxrelay
-
- Copyright 2014 Netflix, Inc.
- Copyright 2015 Jake Wharton
-
-
- rxbinding
-
- Copyright (C) 2015 Jake Wharton
+ Copyright 2019 Yang Chen
Epoxy
diff --git a/vector/src/main/java/im/vector/app/AppStateHandler.kt b/vector/src/main/java/im/vector/app/AppStateHandler.kt
index 30078963f4..9ed9dd5b23 100644
--- a/vector/src/main/java/im/vector/app/AppStateHandler.kt
+++ b/vector/src/main/java/im/vector/app/AppStateHandler.kt
@@ -16,16 +16,20 @@
package im.vector.app
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import arrow.core.Option
import im.vector.app.core.di.ActiveSessionHolder
import im.vector.app.core.utils.BehaviorDataSource
import im.vector.app.features.session.coroutineScope
import im.vector.app.features.ui.UiStateRepository
-import io.reactivex.disposables.CompositeDisposable
+import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.session.Session
@@ -52,12 +56,12 @@ class AppStateHandler @Inject constructor(
private val sessionDataSource: ActiveSessionDataSource,
private val uiStateRepository: UiStateRepository,
private val activeSessionHolder: ActiveSessionHolder
-) : LifecycleObserver {
+) : DefaultLifecycleObserver {
- private val compositeDisposable = CompositeDisposable()
+ private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
private val selectedSpaceDataSource = BehaviorDataSource>(Option.empty())
- val selectedRoomGroupingObservable = selectedSpaceDataSource.observe()
+ val selectedRoomGroupingObservable = selectedSpaceDataSource.stream()
fun getCurrentRoomGroupingMethod(): RoomGroupingMethod? {
// XXX we should somehow make it live :/ just a work around
@@ -105,9 +109,9 @@ class AppStateHandler @Inject constructor(
}
private fun observeActiveSession() {
- sessionDataSource.observe()
+ sessionDataSource.stream()
.distinctUntilChanged()
- .subscribe {
+ .onEach {
// sessionDataSource could already return a session while activeSession holder still returns null
it.orNull()?.let { session ->
if (uiStateRepository.isGroupingMethodSpace(session.sessionId)) {
@@ -116,9 +120,8 @@ class AppStateHandler @Inject constructor(
setCurrentGroup(uiStateRepository.getSelectedGroup(session.sessionId), session)
}
}
- }.also {
- compositeDisposable.add(it)
}
+ .launchIn(coroutineScope)
}
fun safeActiveSpaceId(): String? {
@@ -129,14 +132,12 @@ class AppStateHandler @Inject constructor(
return (selectedSpaceDataSource.currentValue?.orNull() as? RoomGroupingMethod.ByLegacyGroup)?.groupSummary?.groupId
}
- @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
- fun entersForeground() {
+ override fun onResume(owner: LifecycleOwner) {
observeActiveSession()
}
- @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
- fun entersBackground() {
- compositeDisposable.clear()
+ override fun onPause(owner: LifecycleOwner) {
+ coroutineScope.coroutineContext.cancelChildren()
val session = activeSessionHolder.getSafeActiveSession() ?: return
when (val currentMethod = selectedSpaceDataSource.currentValue?.orNull() ?: RoomGroupingMethod.BySpace(null)) {
is RoomGroupingMethod.BySpace -> {
diff --git a/vector/src/main/java/im/vector/app/VectorApplication.kt b/vector/src/main/java/im/vector/app/VectorApplication.kt
index d9027231da..c1d9eef125 100644
--- a/vector/src/main/java/im/vector/app/VectorApplication.kt
+++ b/vector/src/main/java/im/vector/app/VectorApplication.kt
@@ -27,9 +27,8 @@ import android.os.HandlerThread
import android.os.StrictMode
import androidx.core.provider.FontRequest
import androidx.core.provider.FontsContractCompat
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.ProcessLifecycleOwner
import androidx.multidex.MultiDex
import com.airbnb.epoxy.EpoxyAsyncUtil
@@ -43,7 +42,6 @@ import dagger.hilt.android.HiltAndroidApp
import im.vector.app.core.di.ActiveSessionHolder
import im.vector.app.core.extensions.configureAndStart
import im.vector.app.core.extensions.startSyncing
-import im.vector.app.core.rx.RxConfig
import im.vector.app.features.call.webrtc.WebRtcCallManager
import im.vector.app.features.configuration.VectorConfiguration
import im.vector.app.features.disclaimer.doNotShowDisclaimerDialog
@@ -93,7 +91,6 @@ class VectorApplication :
@Inject lateinit var versionProvider: VersionProvider
@Inject lateinit var notificationUtils: NotificationUtils
@Inject lateinit var appStateHandler: AppStateHandler
- @Inject lateinit var rxConfig: RxConfig
@Inject lateinit var popupAlertManager: PopupAlertManager
@Inject lateinit var pinLocker: PinLocker
@Inject lateinit var callManager: WebRtcCallManager
@@ -118,7 +115,6 @@ class VectorApplication :
appContext = this
invitesAcceptor.initialize()
vectorUncaughtExceptionHandler.activate(this)
- rxConfig.setupRxPlugin()
// Remove Log handler statically added by Jitsi
Timber.forest()
@@ -169,9 +165,8 @@ class VectorApplication :
ProcessLifecycleOwner.get().lifecycle.addObserver(startSyncOnFirstStart)
- ProcessLifecycleOwner.get().lifecycle.addObserver(object : LifecycleObserver {
- @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
- fun entersForeground() {
+ ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
+ override fun onResume(owner: LifecycleOwner) {
Timber.i("App entered foreground")
FcmHelper.onEnterForeground(appContext, activeSessionHolder)
activeSessionHolder.getSafeActiveSession()?.also {
@@ -179,8 +174,7 @@ class VectorApplication :
}
}
- @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
- fun entersBackground() {
+ override fun onPause(owner: LifecycleOwner) {
Timber.i("App entered background") // call persistInfo
notificationDrawerManager.persistInfo()
FcmHelper.onEnterBackground(appContext, vectorPreferences, activeSessionHolder)
@@ -201,9 +195,8 @@ class VectorApplication :
EmojiManager.install(GoogleEmojiProvider())
}
- private val startSyncOnFirstStart = object : LifecycleObserver {
- @OnLifecycleEvent(Lifecycle.Event.ON_START)
- fun onStart() {
+ private val startSyncOnFirstStart = object : DefaultLifecycleObserver {
+ override fun onStart(owner: LifecycleOwner) {
Timber.i("App process started")
authenticationService.getLastAuthenticatedSession()?.startSyncing(appContext)
ProcessLifecycleOwner.get().lifecycle.removeObserver(this)
diff --git a/vector/src/main/java/im/vector/app/core/contacts/ContactsDataSource.kt b/vector/src/main/java/im/vector/app/core/contacts/ContactsDataSource.kt
index f5a5e240c6..f99048501d 100644
--- a/vector/src/main/java/im/vector/app/core/contacts/ContactsDataSource.kt
+++ b/vector/src/main/java/im/vector/app/core/contacts/ContactsDataSource.kt
@@ -17,10 +17,10 @@
package im.vector.app.core.contacts
import android.content.Context
-import android.database.Cursor
import android.net.Uri
import android.provider.ContactsContract
import androidx.annotation.WorkerThread
+import im.vector.lib.multipicker.utils.getColumnIndexOrNull
import timber.log.Timber
import javax.inject.Inject
import kotlin.system.measureTimeMillis
@@ -57,16 +57,20 @@ class ContactsDataSource @Inject constructor(
)
?.use { cursor ->
if (cursor.count > 0) {
+ val idColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.Contacts._ID) ?: return@use
+ val displayNameColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.Contacts.DISPLAY_NAME) ?: return@use
+ val photoUriColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.Data.PHOTO_URI)
while (cursor.moveToNext()) {
- val id = cursor.getLong(ContactsContract.Contacts._ID) ?: continue
- val displayName = cursor.getString(ContactsContract.Contacts.DISPLAY_NAME) ?: continue
+ val id = cursor.getLong(idColumnIndex)
+ val displayName = cursor.getString(displayNameColumnIndex)
val mappedContactBuilder = MappedContactBuilder(
id = id,
displayName = displayName
)
- cursor.getString(ContactsContract.Data.PHOTO_URI)
+ photoUriColumnIndex
+ ?.let { cursor.getString(it) }
?.let { Uri.parse(it) }
?.let { mappedContactBuilder.photoURI = it }
@@ -85,12 +89,15 @@ class ContactsDataSource @Inject constructor(
null,
null,
null)
- ?.use { innerCursor ->
- while (innerCursor.moveToNext()) {
- val mappedContactBuilder = innerCursor.getLong(ContactsContract.CommonDataKinds.Phone.CONTACT_ID)
- ?.let { map[it] }
+ ?.use { cursor ->
+ val idColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.CommonDataKinds.Phone.CONTACT_ID) ?: return@use
+ val phoneNumberColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.CommonDataKinds.Phone.NUMBER) ?: return@use
+
+ while (cursor.moveToNext()) {
+ val mappedContactBuilder = cursor.getLong(idColumnIndex)
+ .let { map[it] }
?: continue
- innerCursor.getString(ContactsContract.CommonDataKinds.Phone.NUMBER)
+ cursor.getString(phoneNumberColumnIndex)
?.let {
mappedContactBuilder.msisdns.add(
MappedMsisdn(
@@ -114,14 +121,17 @@ class ContactsDataSource @Inject constructor(
null,
null,
null)
- ?.use { innerCursor ->
- while (innerCursor.moveToNext()) {
+ ?.use { cursor ->
+ val idColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.CommonDataKinds.Email.CONTACT_ID) ?: return@use
+ val emailColumnIndex = cursor.getColumnIndexOrNull(ContactsContract.CommonDataKinds.Email.DATA) ?: return@use
+
+ while (cursor.moveToNext()) {
// This would allow you get several email addresses
// if the email addresses were stored in an array
- val mappedContactBuilder = innerCursor.getLong(ContactsContract.CommonDataKinds.Email.CONTACT_ID)
- ?.let { map[it] }
+ val mappedContactBuilder = cursor.getLong(idColumnIndex)
+ .let { map[it] }
?: continue
- innerCursor.getString(ContactsContract.CommonDataKinds.Email.DATA)
+ cursor.getString(emailColumnIndex)
?.let {
mappedContactBuilder.emails.add(
MappedEmail(
@@ -140,16 +150,4 @@ class ContactsDataSource @Inject constructor(
.filter { it.emails.isNotEmpty() || it.msisdns.isNotEmpty() }
.map { it.build() }
}
-
- private fun Cursor.getString(column: String): String? {
- return getColumnIndex(column)
- .takeIf { it != -1 }
- ?.let { getString(it) }
- }
-
- private fun Cursor.getLong(column: String): Long? {
- return getColumnIndex(column)
- .takeIf { it != -1 }
- ?.let { getLong(it) }
- }
}
diff --git a/vector/src/main/java/im/vector/app/core/di/FragmentModule.kt b/vector/src/main/java/im/vector/app/core/di/FragmentModule.kt
index bf72dcb076..b8d00fac5a 100644
--- a/vector/src/main/java/im/vector/app/core/di/FragmentModule.kt
+++ b/vector/src/main/java/im/vector/app/core/di/FragmentModule.kt
@@ -94,6 +94,7 @@ import im.vector.app.features.login2.terms.LoginTermsFragment2
import im.vector.app.features.matrixto.MatrixToRoomSpaceFragment
import im.vector.app.features.matrixto.MatrixToUserFragment
import im.vector.app.features.pin.PinFragment
+import im.vector.app.features.poll.create.CreatePollFragment
import im.vector.app.features.qrcode.QrCodeScannerFragment
import im.vector.app.features.reactions.EmojiChooserFragment
import im.vector.app.features.reactions.EmojiSearchResultFragment
@@ -111,8 +112,8 @@ import im.vector.app.features.roomprofile.members.RoomMemberListFragment
import im.vector.app.features.roomprofile.notifications.RoomNotificationSettingsFragment
import im.vector.app.features.roomprofile.permissions.RoomPermissionsFragment
import im.vector.app.features.roomprofile.settings.RoomSettingsFragment
-import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleChooseRestrictedFragment
import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleFragment
+import im.vector.app.features.roomprofile.settings.joinrule.advanced.RoomJoinRuleChooseRestrictedFragment
import im.vector.app.features.roomprofile.uploads.RoomUploadsFragment
import im.vector.app.features.roomprofile.uploads.files.RoomUploadsFilesFragment
import im.vector.app.features.roomprofile.uploads.media.RoomUploadsMediaFragment
@@ -837,4 +838,9 @@ interface FragmentModule {
@IntoMap
@FragmentKey(SpaceLeaveAdvancedFragment::class)
fun bindSpaceLeaveAdvancedFragment(fragment: SpaceLeaveAdvancedFragment): Fragment
+
+ @Binds
+ @IntoMap
+ @FragmentKey(CreatePollFragment::class)
+ fun bindCreatePollFragment(fragment: CreatePollFragment): Fragment
}
diff --git a/vector/src/main/java/im/vector/app/core/di/MavericksViewModelModule.kt b/vector/src/main/java/im/vector/app/core/di/MavericksViewModelModule.kt
index f1ff55f765..c827bd0b35 100644
--- a/vector/src/main/java/im/vector/app/core/di/MavericksViewModelModule.kt
+++ b/vector/src/main/java/im/vector/app/core/di/MavericksViewModelModule.kt
@@ -54,6 +54,7 @@ import im.vector.app.features.login.LoginViewModel
import im.vector.app.features.login2.LoginViewModel2
import im.vector.app.features.login2.created.AccountCreatedViewModel
import im.vector.app.features.matrixto.MatrixToBottomSheetViewModel
+import im.vector.app.features.poll.create.CreatePollViewModel
import im.vector.app.features.rageshake.BugReportViewModel
import im.vector.app.features.reactions.EmojiSearchResultViewModel
import im.vector.app.features.room.RequireActiveMembershipViewModel
@@ -546,4 +547,9 @@ interface MavericksViewModelModule {
@IntoMap
@MavericksViewModelKey(VerificationBottomSheetViewModel::class)
fun verificationBottomSheetViewModelFactory(factory: VerificationBottomSheetViewModel.Factory): MavericksAssistedViewModelFactory<*, *>
+
+ @Binds
+ @IntoMap
+ @MavericksViewModelKey(CreatePollViewModel::class)
+ fun createPollViewModelFactory(factory: CreatePollViewModel.Factory): MavericksAssistedViewModelFactory<*, *>
}
diff --git a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
index e89a060022..a3d8f39b30 100644
--- a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
+++ b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
@@ -137,6 +137,6 @@ object VectorStaticModule {
@Provides
@JvmStatic
fun providesCoroutineDispatchers(): CoroutineDispatchers {
- return CoroutineDispatchers(io = Dispatchers.IO)
+ return CoroutineDispatchers(io = Dispatchers.IO, computation = Dispatchers.Default)
}
}
diff --git a/vector/src/main/java/im/vector/app/core/dispatchers/CoroutineDispatchers.kt b/vector/src/main/java/im/vector/app/core/dispatchers/CoroutineDispatchers.kt
index c489290a55..008ca4a9ce 100644
--- a/vector/src/main/java/im/vector/app/core/dispatchers/CoroutineDispatchers.kt
+++ b/vector/src/main/java/im/vector/app/core/dispatchers/CoroutineDispatchers.kt
@@ -19,4 +19,6 @@ package im.vector.app.core.dispatchers
import kotlinx.coroutines.CoroutineDispatcher
import javax.inject.Inject
-data class CoroutineDispatchers @Inject constructor(val io: CoroutineDispatcher)
+data class CoroutineDispatchers @Inject constructor(
+ val io: CoroutineDispatcher,
+ val computation: CoroutineDispatcher)
diff --git a/vector/src/main/java/im/vector/app/core/extensions/BasicExtensions.kt b/vector/src/main/java/im/vector/app/core/extensions/BasicExtensions.kt
index ee3d79d846..dbe90dfdc1 100644
--- a/vector/src/main/java/im/vector/app/core/extensions/BasicExtensions.kt
+++ b/vector/src/main/java/im/vector/app/core/extensions/BasicExtensions.kt
@@ -66,3 +66,7 @@ fun String?.insertBeforeLast(insert: String, delimiter: String = "."): String {
replaceRange(idx, idx, insert)
}
}
+
+inline fun Any?.takeAs(): R? {
+ return takeIf { it is R } as R?
+}
diff --git a/vector/src/main/java/im/vector/app/core/flow/TimingOperators.kt b/vector/src/main/java/im/vector/app/core/flow/TimingOperators.kt
new file mode 100644
index 0000000000..621a80d96e
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/core/flow/TimingOperators.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2021 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.app.core.flow
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.selects.select
+
+@ExperimentalCoroutinesApi
+fun Flow.chunk(durationInMillis: Long): Flow> {
+ require(durationInMillis > 0) { "Duration should be greater than 0" }
+ return flow {
+ coroutineScope {
+ val events = ArrayList()
+ val ticker = fixedPeriodTicker(durationInMillis)
+ try {
+ val upstreamValues = produce(capacity = Channel.CONFLATED) {
+ collect { value -> send(value) }
+ }
+ while (isActive) {
+ var hasTimedOut = false
+ select {
+ upstreamValues.onReceive {
+ events.add(it)
+ }
+ ticker.onReceive {
+ hasTimedOut = true
+ }
+ }
+ if (hasTimedOut && events.isNotEmpty()) {
+ emit(events.toList())
+ events.clear()
+ }
+ }
+ } catch (e: ClosedReceiveChannelException) {
+ // drain remaining events
+ if (events.isNotEmpty()) emit(events.toList())
+ } finally {
+ ticker.cancel()
+ }
+ }
+ }
+}
+
+@ExperimentalCoroutinesApi
+fun Flow.throttleFirst(windowDuration: Long): Flow = flow {
+ var windowStartTime = System.currentTimeMillis()
+ var emitted = false
+ collect { value ->
+ val currentTime = System.currentTimeMillis()
+ val delta = currentTime - windowStartTime
+ if (delta >= windowDuration) {
+ windowStartTime += delta / windowDuration * windowDuration
+ emitted = false
+ }
+ if (!emitted) {
+ emit(value)
+ emitted = true
+ }
+ }
+}
+
+fun tickerFlow(scope: CoroutineScope, delayMillis: Long, initialDelayMillis: Long = delayMillis): Flow {
+ return scope.fixedPeriodTicker(delayMillis, initialDelayMillis).consumeAsFlow()
+}
+
+private fun CoroutineScope.fixedPeriodTicker(delayMillis: Long, initialDelayMillis: Long = delayMillis): ReceiveChannel {
+ require(delayMillis >= 0) { "Expected non-negative delay, but has $delayMillis ms" }
+ require(initialDelayMillis >= 0) { "Expected non-negative initial delay, but has $initialDelayMillis ms" }
+ return produce(capacity = 0) {
+ delay(initialDelayMillis)
+ while (true) {
+ channel.send(Unit)
+ delay(delayMillis)
+ }
+ }
+}
diff --git a/vector/src/main/java/im/vector/app/core/intent/Filename.kt b/vector/src/main/java/im/vector/app/core/intent/Filename.kt
index 5d118c19a1..a38602e4a5 100644
--- a/vector/src/main/java/im/vector/app/core/intent/Filename.kt
+++ b/vector/src/main/java/im/vector/app/core/intent/Filename.kt
@@ -19,15 +19,17 @@ package im.vector.app.core.intent
import android.content.Context
import android.net.Uri
import android.provider.OpenableColumns
+import im.vector.lib.multipicker.utils.getColumnIndexOrNull
fun getFilenameFromUri(context: Context?, uri: Uri): String? {
if (context != null && uri.scheme == "content") {
- val cursor = context.contentResolver.query(uri, null, null, null, null)
- cursor?.use {
- if (it.moveToFirst()) {
- return it.getString(it.getColumnIndex(OpenableColumns.DISPLAY_NAME))
- }
- }
+ context.contentResolver.query(uri, null, null, null, null)
+ ?.use { cursor ->
+ if (cursor.moveToFirst()) {
+ return cursor.getColumnIndexOrNull(OpenableColumns.DISPLAY_NAME)
+ ?.let { cursor.getString(it) }
+ }
+ }
}
return uri.path?.substringAfterLast('/')
}
diff --git a/vector/src/main/java/im/vector/app/core/platform/LifecycleAwareLazy.kt b/vector/src/main/java/im/vector/app/core/platform/LifecycleAwareLazy.kt
index 283106232e..54add00459 100644
--- a/vector/src/main/java/im/vector/app/core/platform/LifecycleAwareLazy.kt
+++ b/vector/src/main/java/im/vector/app/core/platform/LifecycleAwareLazy.kt
@@ -18,58 +18,56 @@ package im.vector.app.core.platform
import androidx.annotation.MainThread
import androidx.fragment.app.Fragment
+import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.OnLifecycleEvent
fun LifecycleOwner.lifecycleAwareLazy(initializer: () -> T): Lazy = LifecycleAwareLazy(this, initializer)
private object UninitializedValue
class LifecycleAwareLazy(
- private val owner: LifecycleOwner,
- initializer: () -> T
-) : Lazy, LifecycleObserver {
+ private val owner: LifecycleOwner,
+ initializer: () -> T
+) : Lazy, DefaultLifecycleObserver {
- private var initializer: (() -> T)? = initializer
+ private var initializer: (() -> T)? = initializer
- private var _value: Any? = UninitializedValue
+ private var _value: Any? = UninitializedValue
- @Suppress("UNCHECKED_CAST")
- override val value: T
- @MainThread
- get() {
- if (_value === UninitializedValue) {
- _value = initializer!!()
- attachToLifecycle()
- }
- return _value as T
+ @Suppress("UNCHECKED_CAST")
+ override val value: T
+ @MainThread
+ get() {
+ if (_value === UninitializedValue) {
+ _value = initializer!!()
+ attachToLifecycle()
+ }
+ return _value as T
+ }
+
+ override fun onDestroy(owner: LifecycleOwner) {
+ _value = UninitializedValue
+ detachFromLifecycle()
}
- @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
- fun resetValue() {
- _value = UninitializedValue
- detachFromLifecycle()
- }
-
- private fun attachToLifecycle() {
- if (getLifecycleOwner().lifecycle.currentState == Lifecycle.State.DESTROYED) {
- throw IllegalStateException("Initialization failed because lifecycle has been destroyed!")
+ private fun attachToLifecycle() {
+ if (getLifecycleOwner().lifecycle.currentState == Lifecycle.State.DESTROYED) {
+ throw IllegalStateException("Initialization failed because lifecycle has been destroyed!")
+ }
+ getLifecycleOwner().lifecycle.addObserver(this)
}
- getLifecycleOwner().lifecycle.addObserver(this)
- }
- private fun detachFromLifecycle() {
- getLifecycleOwner().lifecycle.removeObserver(this)
- }
+ private fun detachFromLifecycle() {
+ getLifecycleOwner().lifecycle.removeObserver(this)
+ }
- private fun getLifecycleOwner() = when (owner) {
- is Fragment -> owner.viewLifecycleOwner
- else -> owner
- }
+ private fun getLifecycleOwner() = when (owner) {
+ is Fragment -> owner.viewLifecycleOwner
+ else -> owner
+ }
- override fun isInitialized(): Boolean = _value !== UninitializedValue
+ override fun isInitialized(): Boolean = _value !== UninitializedValue
- override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
+ override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
}
diff --git a/vector/src/main/java/im/vector/app/core/platform/PendingIntentCompat.kt b/vector/src/main/java/im/vector/app/core/platform/PendingIntentCompat.kt
new file mode 100644
index 0000000000..832c11888c
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/core/platform/PendingIntentCompat.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2021 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.app.core.platform
+
+import android.app.PendingIntent
+import android.os.Build
+
+object PendingIntentCompat {
+ val FLAG_IMMUTABLE = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ PendingIntent.FLAG_IMMUTABLE
+ } else {
+ 0
+ }
+
+ val FLAG_MUTABLE = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ PendingIntent.FLAG_MUTABLE
+ } else {
+ 0
+ }
+}
diff --git a/vector/src/main/java/im/vector/app/core/platform/VectorBaseActivity.kt b/vector/src/main/java/im/vector/app/core/platform/VectorBaseActivity.kt
index 4d06dbe6a2..0fd660effb 100644
--- a/vector/src/main/java/im/vector/app/core/platform/VectorBaseActivity.kt
+++ b/vector/src/main/java/im/vector/app/core/platform/VectorBaseActivity.kt
@@ -16,6 +16,7 @@
package im.vector.app.core.platform
+import android.annotation.SuppressLint
import android.app.Activity
import android.content.Context
import android.content.res.Configuration
@@ -39,12 +40,12 @@ import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentFactory
import androidx.fragment.app.FragmentManager
import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
import androidx.viewbinding.ViewBinding
import com.airbnb.mvrx.MavericksView
import com.bumptech.glide.util.Util
import com.google.android.material.appbar.MaterialToolbar
import com.google.android.material.snackbar.Snackbar
-import com.jakewharton.rxbinding3.view.clicks
import dagger.hilt.android.EntryPointAccessors
import im.vector.app.BuildConfig
import im.vector.app.R
@@ -59,6 +60,7 @@ import im.vector.app.core.extensions.registerStartForActivityResult
import im.vector.app.core.extensions.restart
import im.vector.app.core.extensions.setTextOrHide
import im.vector.app.core.extensions.singletonEntryPoint
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.utils.toast
import im.vector.app.features.MainActivity
import im.vector.app.features.MainActivityArgs
@@ -77,13 +79,12 @@ import im.vector.app.features.settings.VectorPreferences
import im.vector.app.features.themes.ActivityOtherThemes
import im.vector.app.features.themes.ThemeUtils
import im.vector.app.receivers.DebugReceiver
-import io.reactivex.android.schedulers.AndroidSchedulers
-import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.disposables.Disposable
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.failure.GlobalError
+import reactivecircus.flowbinding.android.view.clicks
import timber.log.Timber
-import java.util.concurrent.TimeUnit
import javax.inject.Inject
abstract class VectorBaseActivity : AppCompatActivity(), MavericksView {
@@ -104,13 +105,12 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
protected fun VectorViewModel<*, *, T>.observeViewEvents(observer: (T) -> Unit) {
viewEvents
- .observe()
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .stream()
+ .onEach {
hideWaitingView()
observer(it)
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
}
/* ==========================================================================================
@@ -119,10 +119,9 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
protected fun View.debouncedClicks(onClicked: () -> Unit) {
clicks()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe { onClicked() }
- .disposeOnDestroy()
+ .throttleFirst(300)
+ .onEach { onClicked() }
+ .launchIn(lifecycleScope)
}
/* ==========================================================================================
@@ -133,6 +132,7 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
private lateinit var sessionListener: SessionListener
protected lateinit var bugReporter: BugReporter
private lateinit var pinLocker: PinLocker
+
@Inject
lateinit var rageShake: RageShake
lateinit var navigator: Navigator
@@ -150,7 +150,6 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
// For debug only
private var debugReceiver: DebugReceiver? = null
- private val uiDisposables = CompositeDisposable()
private val restorables = ArrayList()
override fun attachBaseContext(base: Context) {
@@ -175,10 +174,6 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
return this
}
- protected fun Disposable.disposeOnDestroy() {
- uiDisposables.add(this)
- }
-
@CallSuper
override fun onCreate(savedInstanceState: Bundle?) {
Timber.i("onCreate Activity ${javaClass.simpleName}")
@@ -302,8 +297,6 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
override fun onDestroy() {
super.onDestroy()
Timber.i("onDestroy Activity ${javaClass.simpleName}")
-
- uiDisposables.dispose()
}
private val pinStartForActivityResult = registerStartForActivityResult { activityResult ->
@@ -411,7 +404,12 @@ abstract class VectorBaseActivity : AppCompatActivity(), Maver
// New API instead of SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN and SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
window.setDecorFitsSystemWindows(false)
// New API instead of SYSTEM_UI_FLAG_IMMERSIVE
- window.decorView.windowInsetsController?.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_BARS_BY_SWIPE
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ window.decorView.windowInsetsController?.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+ } else {
+ @SuppressLint("WrongConstant")
+ window.decorView.windowInsetsController?.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_BARS_BY_SWIPE
+ }
// New API instead of FLAG_TRANSLUCENT_STATUS
window.statusBarColor = ContextCompat.getColor(this, im.vector.lib.attachmentviewer.R.color.half_transparent_status_bar)
// New API instead of FLAG_TRANSLUCENT_NAVIGATION
diff --git a/vector/src/main/java/im/vector/app/core/platform/VectorBaseBottomSheetDialogFragment.kt b/vector/src/main/java/im/vector/app/core/platform/VectorBaseBottomSheetDialogFragment.kt
index 711b2b144b..20697c6d11 100644
--- a/vector/src/main/java/im/vector/app/core/platform/VectorBaseBottomSheetDialogFragment.kt
+++ b/vector/src/main/java/im/vector/app/core/platform/VectorBaseBottomSheetDialogFragment.kt
@@ -26,21 +26,21 @@ import android.view.ViewGroup
import android.widget.FrameLayout
import androidx.annotation.CallSuper
import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
import androidx.viewbinding.ViewBinding
import com.airbnb.mvrx.Mavericks
import com.airbnb.mvrx.MavericksView
import com.google.android.material.bottomsheet.BottomSheetBehavior
import com.google.android.material.bottomsheet.BottomSheetDialog
import com.google.android.material.bottomsheet.BottomSheetDialogFragment
-import com.jakewharton.rxbinding3.view.clicks
import dagger.hilt.android.EntryPointAccessors
import im.vector.app.core.di.ActivityEntryPoint
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.utils.DimensionConverter
-import io.reactivex.android.schedulers.AndroidSchedulers
-import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.disposables.Disposable
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.view.clicks
import timber.log.Timber
-import java.util.concurrent.TimeUnit
/**
* Add Mavericks capabilities, handle DI and bindings.
@@ -108,14 +108,12 @@ abstract class VectorBaseBottomSheetDialogFragment : BottomShe
@CallSuper
override fun onDestroyView() {
- uiDisposables.clear()
_binding = null
super.onDestroyView()
}
@CallSuper
override fun onDestroy() {
- uiDisposables.dispose()
super.onDestroy()
}
@@ -164,27 +162,15 @@ abstract class VectorBaseBottomSheetDialogFragment : BottomShe
arguments = args?.let { Bundle().apply { putParcelable(Mavericks.KEY_ARG, it) } }
}
- /* ==========================================================================================
- * Disposable
- * ========================================================================================== */
-
- private val uiDisposables = CompositeDisposable()
-
- protected fun Disposable.disposeOnDestroyView(): Disposable {
- uiDisposables.add(this)
- return this
- }
-
/* ==========================================================================================
* Views
* ========================================================================================== */
protected fun View.debouncedClicks(onClicked: () -> Unit) {
clicks()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe { onClicked() }
- .disposeOnDestroyView()
+ .throttleFirst(300)
+ .onEach { onClicked() }
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
/* ==========================================================================================
@@ -193,11 +179,10 @@ abstract class VectorBaseBottomSheetDialogFragment : BottomShe
protected fun VectorViewModel<*, *, T>.observeViewEvents(observer: (T) -> Unit) {
viewEvents
- .observe()
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .stream()
+ .onEach {
observer(it)
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
}
diff --git a/vector/src/main/java/im/vector/app/core/platform/VectorBaseFragment.kt b/vector/src/main/java/im/vector/app/core/platform/VectorBaseFragment.kt
index d3c66ec61d..f4e1fe84e1 100644
--- a/vector/src/main/java/im/vector/app/core/platform/VectorBaseFragment.kt
+++ b/vector/src/main/java/im/vector/app/core/platform/VectorBaseFragment.kt
@@ -29,12 +29,12 @@ import androidx.annotation.MainThread
import androidx.appcompat.app.AlertDialog
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
import androidx.viewbinding.ViewBinding
import com.airbnb.mvrx.MavericksView
import com.bumptech.glide.util.Util.assertMainThread
import com.google.android.material.appbar.MaterialToolbar
import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.jakewharton.rxbinding3.view.clicks
import dagger.hilt.android.EntryPointAccessors
import im.vector.app.R
import im.vector.app.core.di.ActivityEntryPoint
@@ -42,13 +42,13 @@ import im.vector.app.core.dialogs.UnrecognizedCertificateDialog
import im.vector.app.core.error.ErrorFormatter
import im.vector.app.core.extensions.singletonEntryPoint
import im.vector.app.core.extensions.toMvRxBundle
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.features.navigation.Navigator
import im.vector.lib.ui.styles.dialogs.MaterialProgressDialog
-import io.reactivex.android.schedulers.AndroidSchedulers
-import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.disposables.Disposable
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.view.clicks
import timber.log.Timber
-import java.util.concurrent.TimeUnit
abstract class VectorBaseFragment : Fragment(), MavericksView {
@@ -148,7 +148,6 @@ abstract class VectorBaseFragment : Fragment(), MavericksView
@CallSuper
override fun onDestroyView() {
Timber.i("onDestroyView Fragment ${javaClass.simpleName}")
- uiDisposables.clear()
_binding = null
super.onDestroyView()
}
@@ -156,7 +155,6 @@ abstract class VectorBaseFragment : Fragment(), MavericksView
@CallSuper
override fun onDestroy() {
Timber.i("onDestroy Fragment ${javaClass.simpleName}")
- uiDisposables.dispose()
super.onDestroy()
}
@@ -221,29 +219,18 @@ abstract class VectorBaseFragment : Fragment(), MavericksView
}
}
- /* ==========================================================================================
- * Disposable
- * ========================================================================================== */
-
- private val uiDisposables = CompositeDisposable()
-
- protected fun Disposable.disposeOnDestroyView() {
- uiDisposables.add(this)
- }
-
/* ==========================================================================================
* ViewEvents
* ========================================================================================== */
protected fun VectorViewModel<*, *, T>.observeViewEvents(observer: (T) -> Unit) {
viewEvents
- .observe()
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .stream()
+ .onEach {
dismissLoadingDialog()
observer(it)
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
/* ==========================================================================================
@@ -252,10 +239,9 @@ abstract class VectorBaseFragment : Fragment(), MavericksView
protected fun View.debouncedClicks(onClicked: () -> Unit) {
clicks()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe { onClicked() }
- .disposeOnDestroyView()
+ .throttleFirst(300)
+ .onEach { onClicked() }
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
/* ==========================================================================================
diff --git a/vector/src/main/java/im/vector/app/core/platform/VectorViewModel.kt b/vector/src/main/java/im/vector/app/core/platform/VectorViewModel.kt
index 6e7c24d4e9..c9d58f9545 100644
--- a/vector/src/main/java/im/vector/app/core/platform/VectorViewModel.kt
+++ b/vector/src/main/java/im/vector/app/core/platform/VectorViewModel.kt
@@ -16,53 +16,17 @@
package im.vector.app.core.platform
-import com.airbnb.mvrx.Async
-import com.airbnb.mvrx.BaseMvRxViewModel
-import com.airbnb.mvrx.Fail
-import com.airbnb.mvrx.Loading
import com.airbnb.mvrx.MavericksState
-import com.airbnb.mvrx.Success
+import com.airbnb.mvrx.MavericksViewModel
import im.vector.app.core.utils.DataSource
import im.vector.app.core.utils.PublishDataSource
-import io.reactivex.Observable
-import io.reactivex.Single
abstract class VectorViewModel(initialState: S) :
- BaseMvRxViewModel(initialState) {
-
- interface Factory {
- fun create(state: S): BaseMvRxViewModel
- }
+ MavericksViewModel(initialState) {
// Used to post transient events to the View
protected val _viewEvents = PublishDataSource()
val viewEvents: DataSource = _viewEvents
- /**
- * This method does the same thing as the execute function, but it doesn't subscribe to the stream
- * so you can use this in a switchMap or a flatMap
- */
- // False positive
- @Suppress("USELESS_CAST", "NULLABLE_TYPE_PARAMETER_AGAINST_NOT_NULL_TYPE_PARAMETER")
- fun Single.toAsync(stateReducer: S.(Async) -> S): Single> {
- setState { stateReducer(Loading()) }
- return map { Success(it) as Async }
- .onErrorReturn { Fail(it) }
- .doOnSuccess { setState { stateReducer(it) } }
- }
-
- /**
- * This method does the same thing as the execute function, but it doesn't subscribe to the stream
- * so you can use this in a switchMap or a flatMap
- */
- // False positive
- @Suppress("USELESS_CAST", "NULLABLE_TYPE_PARAMETER_AGAINST_NOT_NULL_TYPE_PARAMETER")
- fun Observable.toAsync(stateReducer: S.(Async) -> S): Observable> {
- setState { stateReducer(Loading()) }
- return map { Success(it) as Async }
- .onErrorReturn { Fail(it) }
- .doOnNext { setState { stateReducer(it) } }
- }
-
abstract fun handle(action: VA)
}
diff --git a/vector/src/main/java/im/vector/app/core/rx/RxConfig.kt b/vector/src/main/java/im/vector/app/core/rx/RxConfig.kt
deleted file mode 100644
index ab0ffb7802..0000000000
--- a/vector/src/main/java/im/vector/app/core/rx/RxConfig.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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.app.core.rx
-
-import im.vector.app.features.settings.VectorPreferences
-import io.reactivex.plugins.RxJavaPlugins
-import timber.log.Timber
-import javax.inject.Inject
-
-class RxConfig @Inject constructor(
- private val vectorPreferences: VectorPreferences
-) {
-
- /**
- * Make sure unhandled Rx error does not crash the app in production
- */
- fun setupRxPlugin() {
- RxJavaPlugins.setErrorHandler { throwable ->
- Timber.e(throwable, "RxError")
- // is InterruptedException -> fine, some blocking code was interrupted by a dispose call
- if (throwable !is InterruptedException) {
- // Avoid crash in production, except if user wants it
- if (vectorPreferences.failFast()) {
- throw throwable
- }
- }
- }
- }
-}
diff --git a/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt b/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
index 08db8227a6..a6f6d8d82f 100644
--- a/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
+++ b/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
@@ -32,6 +32,7 @@ import androidx.work.Worker
import androidx.work.WorkerParameters
import dagger.hilt.android.AndroidEntryPoint
import im.vector.app.R
+import im.vector.app.core.platform.PendingIntentCompat
import im.vector.app.features.notifications.NotificationUtils
import im.vector.app.features.settings.BackgroundSyncMode
import org.matrix.android.sdk.internal.session.sync.job.SyncService
@@ -199,9 +200,9 @@ private fun Context.rescheduleSyncService(sessionId: String,
startService(intent)
} else {
val pendingIntent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
- PendingIntent.getForegroundService(this, 0, intent, 0)
+ PendingIntent.getForegroundService(this, 0, intent, PendingIntentCompat.FLAG_IMMUTABLE)
} else {
- PendingIntent.getService(this, 0, intent, 0)
+ PendingIntent.getService(this, 0, intent, PendingIntentCompat.FLAG_IMMUTABLE)
}
val firstMillis = System.currentTimeMillis() + syncDelaySeconds * 1000L
val alarmMgr = getSystemService()!!
diff --git a/vector/src/main/java/im/vector/app/core/ui/list/GenericButtonItem.kt b/vector/src/main/java/im/vector/app/core/ui/list/GenericButtonItem.kt
index eb683631fd..fe59c82ce9 100644
--- a/vector/src/main/java/im/vector/app/core/ui/list/GenericButtonItem.kt
+++ b/vector/src/main/java/im/vector/app/core/ui/list/GenericButtonItem.kt
@@ -15,6 +15,8 @@
*/
package im.vector.app.core.ui.list
+import android.graphics.Typeface
+import android.view.Gravity
import androidx.annotation.ColorInt
import androidx.annotation.DrawableRes
import com.airbnb.epoxy.EpoxyAttribute
@@ -47,6 +49,12 @@ abstract class GenericButtonItem : VectorEpoxyModel()
@DrawableRes
var iconRes: Int? = null
+ @EpoxyAttribute
+ var gravity: Int = Gravity.CENTER
+
+ @EpoxyAttribute
+ var bold: Boolean = false
+
override fun bind(holder: Holder) {
super.bind(holder)
holder.button.text = text
@@ -58,6 +66,10 @@ abstract class GenericButtonItem : VectorEpoxyModel()
holder.button.icon = null
}
+ holder.button.gravity = gravity or Gravity.CENTER_VERTICAL
+ val textStyle = if (bold) Typeface.BOLD else Typeface.NORMAL
+ holder.button.setTypeface(null, textStyle)
+
holder.button.onClick(buttonClickAction)
}
diff --git a/vector/src/main/java/im/vector/app/core/utils/CountUpTimer.kt b/vector/src/main/java/im/vector/app/core/utils/CountUpTimer.kt
index a029f4eec9..b58d0fb3f6 100644
--- a/vector/src/main/java/im/vector/app/core/utils/CountUpTimer.kt
+++ b/vector/src/main/java/im/vector/app/core/utils/CountUpTimer.kt
@@ -16,23 +16,36 @@
package im.vector.app.core.utils
-import io.reactivex.Observable
-import java.util.concurrent.TimeUnit
+import im.vector.app.core.flow.tickerFlow
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
class CountUpTimer(private val intervalInMs: Long = 1_000) {
+ private val coroutineScope = CoroutineScope(Dispatchers.Main)
private val elapsedTime: AtomicLong = AtomicLong()
private val resumed: AtomicBoolean = AtomicBoolean(false)
- private val disposable = Observable.interval(intervalInMs / 10, TimeUnit.MILLISECONDS)
- .filter { resumed.get() }
- .map { elapsedTime.addAndGet(intervalInMs / 10) }
- .filter { it % intervalInMs == 0L }
- .subscribe {
- tickListener?.onTick(it)
- }
+ init {
+ startCounter()
+ }
+
+ private fun startCounter() {
+ tickerFlow(coroutineScope, intervalInMs / 10)
+ .filter { resumed.get() }
+ .map { elapsedTime.addAndGet(intervalInMs / 10) }
+ .filter { it % intervalInMs == 0L }
+ .onEach {
+ tickListener?.onTick(it)
+ }.launchIn(coroutineScope)
+ }
var tickListener: TickListener? = null
@@ -49,7 +62,7 @@ class CountUpTimer(private val intervalInMs: Long = 1_000) {
}
fun stop() {
- disposable.dispose()
+ coroutineScope.cancel()
}
interface TickListener {
diff --git a/vector/src/main/java/im/vector/app/core/utils/DataSource.kt b/vector/src/main/java/im/vector/app/core/utils/DataSource.kt
index fc4ee330bb..f83eda68e9 100644
--- a/vector/src/main/java/im/vector/app/core/utils/DataSource.kt
+++ b/vector/src/main/java/im/vector/app/core/utils/DataSource.kt
@@ -16,13 +16,12 @@
package im.vector.app.core.utils
-import com.jakewharton.rxrelay2.BehaviorRelay
-import com.jakewharton.rxrelay2.PublishRelay
-import io.reactivex.Observable
-import io.reactivex.android.schedulers.AndroidSchedulers
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
interface DataSource {
- fun observe(): Observable
+ fun stream(): Flow
}
interface MutableDataSource : DataSource {
@@ -34,25 +33,17 @@ interface MutableDataSource : DataSource {
*/
open class BehaviorDataSource(private val defaultValue: T? = null) : MutableDataSource {
- private val behaviorRelay = createRelay()
+ private val mutableFlow = MutableSharedFlow(replay = 1)
val currentValue: T?
- get() = behaviorRelay.value
+ get() = mutableFlow.replayCache.firstOrNull()
- override fun observe(): Observable {
- return behaviorRelay.hide().observeOn(AndroidSchedulers.mainThread())
+ override fun stream(): Flow {
+ return mutableFlow
}
override fun post(value: T) {
- behaviorRelay.accept(value!!)
- }
-
- private fun createRelay(): BehaviorRelay {
- return if (defaultValue == null) {
- BehaviorRelay.create()
- } else {
- BehaviorRelay.createDefault(defaultValue)
- }
+ mutableFlow.tryEmit(value)
}
}
@@ -61,13 +52,13 @@ open class BehaviorDataSource(private val defaultValue: T? = null) : MutableD
*/
open class PublishDataSource : MutableDataSource {
- private val publishRelay = PublishRelay.create()
+ private val mutableFlow = MutableSharedFlow(replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
- override fun observe(): Observable {
- return publishRelay.hide().observeOn(AndroidSchedulers.mainThread())
+ override fun stream(): Flow {
+ return mutableFlow
}
override fun post(value: T) {
- publishRelay.accept(value!!)
+ mutableFlow.tryEmit(value)
}
}
diff --git a/vector/src/main/java/im/vector/app/core/utils/Dialogs.kt b/vector/src/main/java/im/vector/app/core/utils/Dialogs.kt
index ed3ae00567..ad62b0fcb1 100644
--- a/vector/src/main/java/im/vector/app/core/utils/Dialogs.kt
+++ b/vector/src/main/java/im/vector/app/core/utils/Dialogs.kt
@@ -42,8 +42,8 @@ fun Context.displayInWebView(url: String) {
fun Context.showIdentityServerConsentDialog(configuredIdentityServer: String?, policyLinkCallback: () -> Unit, consentCallBack: (() -> Unit)) {
MaterialAlertDialogBuilder(this)
- .setTitle(R.string.identity_server_consent_dialog_title)
- .setMessage(getString(R.string.identity_server_consent_dialog_content, configuredIdentityServer ?: ""))
+ .setTitle(getString(R.string.identity_server_consent_dialog_title_2, configuredIdentityServer ?: ""))
+ .setMessage(R.string.identity_server_consent_dialog_content_2)
.setPositiveButton(R.string.yes) { _, _ ->
consentCallBack.invoke()
}
diff --git a/vector/src/main/java/im/vector/app/features/attachments/AttachmentTypeSelectorView.kt b/vector/src/main/java/im/vector/app/features/attachments/AttachmentTypeSelectorView.kt
index 35644e1843..6c349d18dc 100644
--- a/vector/src/main/java/im/vector/app/features/attachments/AttachmentTypeSelectorView.kt
+++ b/vector/src/main/java/im/vector/app/features/attachments/AttachmentTypeSelectorView.kt
@@ -75,6 +75,7 @@ class AttachmentTypeSelectorView(context: Context,
views.attachmentStickersButton.configure(Type.STICKER)
views.attachmentAudioButton.configure(Type.AUDIO)
views.attachmentContactButton.configure(Type.CONTACT)
+ views.attachmentPollButton.configure(Type.POLL)
width = LinearLayout.LayoutParams.MATCH_PARENT
height = LinearLayout.LayoutParams.WRAP_CONTENT
animationStyle = 0
@@ -108,6 +109,7 @@ class AttachmentTypeSelectorView(context: Context,
animateButtonIn(views.attachmentAudioButton, 0)
animateButtonIn(views.attachmentContactButton, ANIMATION_DURATION / 4)
animateButtonIn(views.attachmentStickersButton, ANIMATION_DURATION / 2)
+ animateButtonIn(views.attachmentPollButton, ANIMATION_DURATION / 4)
}
override fun dismiss() {
@@ -212,6 +214,7 @@ class AttachmentTypeSelectorView(context: Context,
FILE(PERMISSIONS_EMPTY),
STICKER(PERMISSIONS_EMPTY),
AUDIO(PERMISSIONS_EMPTY),
- CONTACT(PERMISSIONS_FOR_PICKING_CONTACT)
+ CONTACT(PERMISSIONS_FOR_PICKING_CONTACT),
+ POLL(PERMISSIONS_EMPTY)
}
}
diff --git a/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt b/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt
index b4f49db781..e38b53c858 100644
--- a/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt
+++ b/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt
@@ -39,7 +39,7 @@ class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment(), CallContro
setSupportActionBar(views.callToolbar)
configureCallViews()
- callViewModel.subscribe(this) {
+ callViewModel.onEach {
renderState(it)
}
@@ -141,12 +143,11 @@ class VectorCallActivity : VectorBaseActivity(), CallContro
}
callViewModel.viewEvents
- .observe()
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .stream()
+ .onEach {
handleViewEvents(it)
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
callViewModel.onEach(VectorCallViewState::callId, VectorCallViewState::isVideoCall) { _, isVideoCall ->
if (isVideoCall) {
diff --git a/vector/src/main/java/im/vector/app/features/call/conference/ConferenceEvent.kt b/vector/src/main/java/im/vector/app/features/call/conference/ConferenceEvent.kt
index 0a63ad6907..0d8e538eca 100644
--- a/vector/src/main/java/im/vector/app/features/call/conference/ConferenceEvent.kt
+++ b/vector/src/main/java/im/vector/app/features/call/conference/ConferenceEvent.kt
@@ -20,9 +20,8 @@ import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import com.facebook.react.bridge.JavaOnlyMap
import org.jitsi.meet.sdk.BroadcastEmitter
@@ -42,7 +41,7 @@ sealed class ConferenceEvent(open val data: Map) {
}
}
-class ConferenceEventEmitter(private val context: Context) {
+class ConferenceEventEmitter(private val context: Context) {
fun emitConferenceEnded() {
val broadcastEventData = JavaOnlyMap.of(CONFERENCE_URL_DATA_KEY, JitsiMeet.getCurrentConference())
@@ -52,7 +51,7 @@ class ConferenceEventEmitter(private val context: Context) {
class ConferenceEventObserver(private val context: Context,
private val onBroadcastEvent: (ConferenceEvent) -> Unit) :
- LifecycleObserver {
+ DefaultLifecycleObserver {
// See https://jitsi.github.io/handbook/docs/dev-guide/dev-guide-android-sdk#listening-for-broadcasted-events
private val broadcastReceiver = object : BroadcastReceiver() {
@@ -61,8 +60,7 @@ class ConferenceEventObserver(private val context: Context,
}
}
- @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
- fun unregisterForBroadcastMessages() {
+ override fun onDestroy(owner: LifecycleOwner) {
try {
LocalBroadcastManager.getInstance(context).unregisterReceiver(broadcastReceiver)
} catch (throwable: Throwable) {
@@ -70,8 +68,7 @@ class ConferenceEventObserver(private val context: Context,
}
}
- @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
- fun registerForBroadcastMessages() {
+ override fun onCreate(owner: LifecycleOwner) {
val intentFilter = IntentFilter()
for (type in BroadcastEvent.Type.values()) {
intentFilter.addAction(type.action)
diff --git a/vector/src/main/java/im/vector/app/features/call/conference/VectorJitsiActivity.kt b/vector/src/main/java/im/vector/app/features/call/conference/VectorJitsiActivity.kt
index 3fcefc9c8e..0fdfea8bff 100644
--- a/vector/src/main/java/im/vector/app/features/call/conference/VectorJitsiActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/call/conference/VectorJitsiActivity.kt
@@ -68,7 +68,7 @@ class VectorJitsiActivity : VectorBaseActivity(), JitsiMee
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
- jitsiViewModel.subscribe(this) {
+ jitsiViewModel.onEach {
renderState(it)
}
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt
index e632d00790..bbb158f6e4 100644
--- a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt
+++ b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt
@@ -19,8 +19,10 @@ package im.vector.app.features.call.webrtc
import android.content.Context
import android.hardware.camera2.CameraManager
import androidx.core.content.getSystemService
+import im.vector.app.core.flow.chunk
import im.vector.app.core.services.CallService
import im.vector.app.core.utils.CountUpTimer
+import im.vector.app.core.utils.PublishDataSource
import im.vector.app.core.utils.TextUtils.formatDuration
import im.vector.app.features.call.CameraEventsHandlerAdapter
import im.vector.app.features.call.CameraProxy
@@ -35,14 +37,16 @@ import im.vector.app.features.call.utils.awaitSetLocalDescription
import im.vector.app.features.call.utils.awaitSetRemoteDescription
import im.vector.app.features.call.utils.mapToCallCandidate
import im.vector.app.features.session.coroutineScope
-import io.reactivex.disposables.Disposable
-import io.reactivex.subjects.PublishSubject
-import io.reactivex.subjects.ReplaySubject
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.matrix.android.sdk.api.extensions.orFalse
@@ -85,7 +89,6 @@ import org.webrtc.VideoTrack
import timber.log.Timber
import java.lang.ref.WeakReference
import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.TimeUnit
import javax.inject.Provider
import kotlin.coroutines.CoroutineContext
@@ -157,7 +160,7 @@ class WebRtcCall(
private var currentCaptureFormat: CaptureFormat = CaptureFormat.HD
private var cameraAvailabilityCallback: CameraManager.AvailabilityCallback? = null
- private val timer = CountUpTimer(Duration.ofSeconds(1).toMillis()).apply {
+ private val timer = CountUpTimer(1000L).apply {
tickListener = object : CountUpTimer.TickListener {
override fun onTick(milliseconds: Long) {
val formattedDuration = formatDuration(Duration.ofMillis(milliseconds))
@@ -197,26 +200,33 @@ class WebRtcCall(
private var localSurfaceRenderers: MutableList> = ArrayList()
private var remoteSurfaceRenderers: MutableList> = ArrayList()
- private val iceCandidateSource: PublishSubject = PublishSubject.create()
- private val iceCandidateDisposable = iceCandidateSource
- .buffer(300, TimeUnit.MILLISECONDS)
- .subscribe {
- // omit empty :/
- if (it.isNotEmpty()) {
- Timber.tag(loggerTag.value).v("Sending local ice candidates to call")
- // it.forEach { peerConnection?.addIceCandidate(it) }
- mxCall.sendLocalCallCandidates(it.mapToCallCandidate())
- }
- }
+ private val localIceCandidateSource = PublishDataSource()
+ private var localIceCandidateJob: Job? = null
- private val remoteCandidateSource: ReplaySubject = ReplaySubject.create()
- private var remoteIceCandidateDisposable: Disposable? = null
+ private val remoteCandidateSource: MutableSharedFlow = MutableSharedFlow(replay = Int.MAX_VALUE)
+ private var remoteIceCandidateJob: Job? = null
init {
+ setupLocalIceCanditate()
mxCall.addListener(this)
}
- fun onIceCandidate(iceCandidate: IceCandidate) = iceCandidateSource.onNext(iceCandidate)
+ private fun setupLocalIceCanditate() {
+ sessionScope?.let {
+ localIceCandidateJob = localIceCandidateSource.stream()
+ .chunk(300)
+ .onEach {
+ // omit empty :/
+ if (it.isNotEmpty()) {
+ Timber.tag(loggerTag.value).v("Sending local ice candidates to call")
+ // it.forEach { peerConnection?.addIceCandidate(it) }
+ mxCall.sendLocalCallCandidates(it.mapToCallCandidate())
+ }
+ }.launchIn(it)
+ }
+ }
+
+ fun onIceCandidate(iceCandidate: IceCandidate) = localIceCandidateSource.post(iceCandidate)
fun onRenegotiationNeeded(restartIce: Boolean) {
sessionScope?.launch(dispatcher) {
@@ -438,12 +448,15 @@ class WebRtcCall(
createLocalStream()
attachViewRenderersInternal()
Timber.tag(loggerTag.value).v("remoteCandidateSource $remoteCandidateSource")
- remoteIceCandidateDisposable = remoteCandidateSource.subscribe({
- Timber.tag(loggerTag.value).v("adding remote ice candidate $it")
- peerConnection?.addIceCandidate(it)
- }, {
- Timber.tag(loggerTag.value).v("failed to add remote ice candidate $it")
- })
+ remoteIceCandidateJob = remoteCandidateSource
+ .onEach {
+ Timber.tag(loggerTag.value).v("adding remote ice candidate $it")
+ peerConnection?.addIceCandidate(it)
+ }
+ .catch {
+ Timber.tag(loggerTag.value).v("failed to add remote ice candidate $it")
+ }
+ .launchIn(this)
// Now we wait for negotiation callback
}
@@ -488,12 +501,13 @@ class WebRtcCall(
mxCall.accept(it.description)
}
Timber.tag(loggerTag.value).v("remoteCandidateSource $remoteCandidateSource")
- remoteIceCandidateDisposable = remoteCandidateSource.subscribe({
- Timber.tag(loggerTag.value).v("adding remote ice candidate $it")
- peerConnection?.addIceCandidate(it)
- }, {
- Timber.tag(loggerTag.value).v("failed to add remote ice candidate $it")
- })
+ remoteIceCandidateJob = remoteCandidateSource
+ .onEach {
+ Timber.tag(loggerTag.value).v("adding remote ice candidate $it")
+ peerConnection?.addIceCandidate(it)
+ }.catch {
+ Timber.tag(loggerTag.value).v("failed to add remote ice candidate $it")
+ }.launchIn(this)
}
private suspend fun getTurnServer(): TurnServerResponse? {
@@ -761,8 +775,8 @@ class WebRtcCall(
videoCapturer?.stopCapture()
videoCapturer?.dispose()
videoCapturer = null
- remoteIceCandidateDisposable?.dispose()
- iceCandidateDisposable?.dispose()
+ remoteIceCandidateJob?.cancel()
+ localIceCandidateJob?.cancel()
peerConnection?.close()
peerConnection?.dispose()
localAudioSource?.dispose()
@@ -852,7 +866,7 @@ class WebRtcCall(
}
Timber.tag(loggerTag.value).v("onCallIceCandidateReceived for call ${mxCall.callId} sdp: ${it.candidate}")
val iceCandidate = IceCandidate(it.sdpMid, it.sdpMLineIndex, it.candidate)
- remoteCandidateSource.onNext(iceCandidate)
+ remoteCandidateSource.emit(iceCandidate)
}
}
}
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
index 9e620174f3..80390a7dfb 100644
--- a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
+++ b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
@@ -17,9 +17,8 @@
package im.vector.app.features.call.webrtc
import android.content.Context
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import im.vector.app.ActiveSessionDataSource
import im.vector.app.BuildConfig
import im.vector.app.core.services.CallService
@@ -70,7 +69,8 @@ private val loggerTag = LoggerTag("WebRtcCallManager", LoggerTag.VOIP)
class WebRtcCallManager @Inject constructor(
private val context: Context,
private val activeSessionDataSource: ActiveSessionDataSource
-) : CallListener, LifecycleObserver {
+) : CallListener,
+ DefaultLifecycleObserver {
private val currentSession: Session?
get() = activeSessionDataSource.currentValue?.orNull()
@@ -133,13 +133,11 @@ class WebRtcCallManager @Inject constructor(
private var isInBackground: Boolean = true
- @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
- fun entersForeground() {
+ override fun onResume(owner: LifecycleOwner) {
isInBackground = false
}
- @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
- fun entersBackground() {
+ override fun onPause(owner: LifecycleOwner) {
isInBackground = true
}
diff --git a/vector/src/main/java/im/vector/app/features/command/Command.kt b/vector/src/main/java/im/vector/app/features/command/Command.kt
index ccabd25ff4..1950038691 100644
--- a/vector/src/main/java/im/vector/app/features/command/Command.kt
+++ b/vector/src/main/java/im/vector/app/features/command/Command.kt
@@ -47,7 +47,6 @@ enum class Command(val command: String, val parameters: String, @StringRes val d
RAINBOW_EMOTE("/rainbowme", "", R.string.command_description_rainbow_emote, false),
CLEAR_SCALAR_TOKEN("/clear_scalar_token", "", R.string.command_description_clear_scalar_token, false),
SPOILER("/spoiler", "", R.string.command_description_spoiler, false),
- POLL("/poll", "Question | Option 1 | Option 2 ...", R.string.command_description_poll, false),
SHRUG("/shrug", "", R.string.command_description_shrug, false),
LENNY("/lenny", "", R.string.command_description_lenny, false),
PLAIN("/plain", "", R.string.command_description_plain, false),
diff --git a/vector/src/main/java/im/vector/app/features/command/CommandParser.kt b/vector/src/main/java/im/vector/app/features/command/CommandParser.kt
index 3a6b005d6f..4b2a4aa28c 100644
--- a/vector/src/main/java/im/vector/app/features/command/CommandParser.kt
+++ b/vector/src/main/java/im/vector/app/features/command/CommandParser.kt
@@ -345,15 +345,6 @@ object CommandParser {
ParsedCommand.SendLenny(message)
}
- Command.POLL.command -> {
- val rawCommand = textMessage.substring(Command.POLL.command.length).trim()
- val split = rawCommand.split("|").map { it.trim() }
- if (split.size > 2) {
- ParsedCommand.SendPoll(split[0], split.subList(1, split.size))
- } else {
- ParsedCommand.ErrorSyntax(Command.POLL)
- }
- }
Command.DISCARD_SESSION.command -> {
ParsedCommand.DiscardSession
}
diff --git a/vector/src/main/java/im/vector/app/features/command/ParsedCommand.kt b/vector/src/main/java/im/vector/app/features/command/ParsedCommand.kt
index 89aa8d9188..4f8d19abb6 100644
--- a/vector/src/main/java/im/vector/app/features/command/ParsedCommand.kt
+++ b/vector/src/main/java/im/vector/app/features/command/ParsedCommand.kt
@@ -61,7 +61,6 @@ sealed class ParsedCommand {
class SendSpoiler(val message: String) : ParsedCommand()
class SendShrug(val message: CharSequence) : ParsedCommand()
class SendLenny(val message: CharSequence) : ParsedCommand()
- class SendPoll(val question: String, val options: List) : ParsedCommand()
object DiscardSession : ParsedCommand()
class ShowUser(val userId: String) : ParsedCommand()
class SendChatEffect(val chatEffect: ChatEffect, val message: String) : ParsedCommand()
diff --git a/vector/src/main/java/im/vector/app/features/contactsbook/ContactsBookFragment.kt b/vector/src/main/java/im/vector/app/features/contactsbook/ContactsBookFragment.kt
index d79ad308de..95c6105912 100644
--- a/vector/src/main/java/im/vector/app/features/contactsbook/ContactsBookFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/contactsbook/ContactsBookFragment.kt
@@ -21,10 +21,9 @@ import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.activityViewModel
import com.airbnb.mvrx.withState
-import com.jakewharton.rxbinding3.widget.checkedChanges
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.core.extensions.cleanup
import im.vector.app.core.extensions.configureWith
import im.vector.app.core.extensions.hideKeyboard
@@ -37,9 +36,13 @@ import im.vector.app.features.userdirectory.UserListAction
import im.vector.app.features.userdirectory.UserListSharedAction
import im.vector.app.features.userdirectory.UserListSharedActionViewModel
import im.vector.app.features.userdirectory.UserListViewModel
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.session.identity.ThreePid
import org.matrix.android.sdk.api.session.user.model.User
-import java.util.concurrent.TimeUnit
+import reactivecircus.flowbinding.android.widget.checkedChanges
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class ContactsBookFragment @Inject constructor(
@@ -83,21 +86,21 @@ class ContactsBookFragment @Inject constructor(
private fun setupOnlyBoundContactsView() {
views.phoneBookOnlyBoundContacts.checkedChanges()
- .subscribe {
+ .onEach {
contactsBookViewModel.handle(ContactsBookAction.OnlyBoundContacts(it))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun setupFilterView() {
views.phoneBookFilter
.textChanges()
.skipInitialValue()
- .debounce(300, TimeUnit.MILLISECONDS)
- .subscribe {
+ .debounce(300)
+ .onEach {
contactsBookViewModel.handle(ContactsBookAction.FilterWith(it.toString()))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
override fun onDestroyView() {
diff --git a/vector/src/main/java/im/vector/app/features/createdirect/CreateDirectRoomActivity.kt b/vector/src/main/java/im/vector/app/features/createdirect/CreateDirectRoomActivity.kt
index 28da72714a..3ff989da5a 100644
--- a/vector/src/main/java/im/vector/app/features/createdirect/CreateDirectRoomActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/createdirect/CreateDirectRoomActivity.kt
@@ -22,6 +22,7 @@ import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.view.View
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.Async
import com.airbnb.mvrx.Fail
import com.airbnb.mvrx.Loading
@@ -46,6 +47,8 @@ import im.vector.app.features.userdirectory.UserListFragment
import im.vector.app.features.userdirectory.UserListFragmentArgs
import im.vector.app.features.userdirectory.UserListSharedAction
import im.vector.app.features.userdirectory.UserListSharedActionViewModel
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.failure.Failure
import org.matrix.android.sdk.api.session.room.failure.CreateRoomFailure
import java.net.HttpURLConnection
@@ -64,8 +67,8 @@ class CreateDirectRoomActivity : SimpleFragmentActivity() {
sharedActionViewModel = viewModelProvider.get(UserListSharedActionViewModel::class.java)
sharedActionViewModel
- .observe()
- .subscribe { action ->
+ .stream()
+ .onEach { action ->
when (action) {
UserListSharedAction.Close -> finish()
UserListSharedAction.GoBack -> onBackPressed()
@@ -74,7 +77,7 @@ class CreateDirectRoomActivity : SimpleFragmentActivity() {
UserListSharedAction.AddByQrCode -> openAddByQrCode()
}.exhaustive
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
if (isFirstCreation()) {
addFragment(
R.id.container,
diff --git a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt
index ddbe86305c..a0a6a138dc 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt
@@ -29,13 +29,8 @@ class KeysBackupRestoreFromKeyViewModel @Inject constructor(
private val stringProvider: StringProvider
) : ViewModel() {
- var recoveryCode: MutableLiveData = MutableLiveData()
- var recoveryCodeErrorText: MutableLiveData = MutableLiveData()
-
- init {
- recoveryCode.value = null
- recoveryCodeErrorText.value = null
- }
+ var recoveryCode: MutableLiveData = MutableLiveData(null)
+ var recoveryCodeErrorText: MutableLiveData = MutableLiveData(null)
// ========= Actions =========
fun updateCode(newValue: String) {
diff --git a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt
index af5938e20a..81d3c64dec 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt
@@ -28,13 +28,8 @@ class KeysBackupRestoreFromPassphraseViewModel @Inject constructor(
private val stringProvider: StringProvider
) : ViewModel() {
- var passphrase: MutableLiveData = MutableLiveData()
- var passphraseErrorText: MutableLiveData = MutableLiveData()
-
- init {
- passphrase.value = null
- passphraseErrorText.value = null
- }
+ var passphrase: MutableLiveData = MutableLiveData(null)
+ var passphraseErrorText: MutableLiveData = MutableLiveData(null)
// ========= Actions =========
diff --git a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt
index 34a333d588..8362a3566e 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt
@@ -57,7 +57,7 @@ class KeysBackupRestoreSharedViewModel @Inject constructor(
lateinit var session: Session
- var keyVersionResult: MutableLiveData = MutableLiveData()
+ var keyVersionResult: MutableLiveData = MutableLiveData(null)
var keySourceModel: MutableLiveData = MutableLiveData()
@@ -69,17 +69,11 @@ class KeysBackupRestoreSharedViewModel @Inject constructor(
val navigateEvent: LiveData>
get() = _navigateEvent
- var loadingEvent: MutableLiveData = MutableLiveData()
+ var loadingEvent: MutableLiveData = MutableLiveData(null)
var importKeyResult: ImportRoomKeysResult? = null
var importRoomKeysFinishWithResult: MutableLiveData> = MutableLiveData()
- init {
- keyVersionResult.value = null
- _keyVersionResultError.value = null
- loadingEvent.value = null
- }
-
fun initSession(session: Session) {
this.session = session
}
diff --git a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt
index cd59a69a86..1141886689 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt
@@ -68,23 +68,15 @@ class KeysBackupSetupSharedViewModel @Inject constructor() : ViewModel() {
// Step 3
// Var to ignore events from previous request(s) to generate a recovery key
private var currentRequestId: MutableLiveData = MutableLiveData()
- var recoveryKey: MutableLiveData = MutableLiveData()
- var prepareRecoverFailError: MutableLiveData = MutableLiveData()
+ var recoveryKey: MutableLiveData = MutableLiveData(null)
+ var prepareRecoverFailError: MutableLiveData = MutableLiveData(null)
var megolmBackupCreationInfo: MegolmBackupCreationInfo? = null
var copyHasBeenMade = false
- var isCreatingBackupVersion: MutableLiveData = MutableLiveData()
- var creatingBackupError: MutableLiveData = MutableLiveData()
+ var isCreatingBackupVersion: MutableLiveData = MutableLiveData(false)
+ var creatingBackupError: MutableLiveData = MutableLiveData(null)
var keysVersion: MutableLiveData = MutableLiveData()
- var loadingStatus: MutableLiveData = MutableLiveData()
-
- init {
- recoveryKey.value = null
- isCreatingBackupVersion.value = false
- prepareRecoverFailError.value = null
- creatingBackupError.value = null
- loadingStatus.value = null
- }
+ var loadingStatus: MutableLiveData = MutableLiveData(null)
fun initSession(session: Session) {
this.session = session
diff --git a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecureStorageActivity.kt b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecureStorageActivity.kt
index 61c8ab8f0a..bb854aca26 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecureStorageActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecureStorageActivity.kt
@@ -63,7 +63,7 @@ class SharedSecureStorageActivity :
viewModel.observeViewEvents { observeViewEvents(it) }
- viewModel.subscribe(this) { renderState(it) }
+ viewModel.onEach { renderState(it) }
}
override fun onDestroy() {
diff --git a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageKeyFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageKeyFragment.kt
index 1ba0198cb4..c49291d6a2 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageKeyFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageKeyFragment.kt
@@ -22,17 +22,19 @@ import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.activityViewModel
-import com.jakewharton.rxbinding3.widget.editorActionEvents
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.registerStartForActivityResult
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.core.utils.startImportTextFromFileIntent
import im.vector.app.databinding.FragmentSsssAccessFromKeyBinding
-import io.reactivex.android.schedulers.AndroidSchedulers
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.extensions.tryOrNull
-import java.util.concurrent.TimeUnit
+import reactivecircus.flowbinding.android.widget.editorActionEvents
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class SharedSecuredStorageKeyFragment @Inject constructor() : VectorBaseFragment() {
@@ -48,22 +50,21 @@ class SharedSecuredStorageKeyFragment @Inject constructor() : VectorBaseFragment
views.ssssRestoreWithKeyText.text = getString(R.string.enter_secret_storage_input_key)
views.ssssKeyEnterEdittext.editorActionEvents()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
if (it.actionId == EditorInfo.IME_ACTION_DONE) {
submit()
}
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssKeyEnterEdittext.textChanges()
.skipInitialValue()
- .subscribe {
+ .onEach {
views.ssssKeyEnterTil.error = null
views.ssssKeySubmit.isEnabled = it.isNotBlank()
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssKeyUseFile.debouncedClicks { startImportTextFromFileIntent(requireContext(), importFileStartForActivityResult) }
diff --git a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStoragePassphraseFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStoragePassphraseFragment.kt
index 800b02a936..c93e562d77 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStoragePassphraseFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStoragePassphraseFragment.kt
@@ -22,15 +22,17 @@ import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import androidx.core.text.toSpannable
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.activityViewModel
-import com.jakewharton.rxbinding3.widget.editorActionEvents
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.core.resources.ColorProvider
import im.vector.app.databinding.FragmentSsssAccessFromPassphraseBinding
-import io.reactivex.android.schedulers.AndroidSchedulers
-import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.widget.editorActionEvents
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class SharedSecuredStoragePassphraseFragment @Inject constructor(
@@ -60,21 +62,20 @@ class SharedSecuredStoragePassphraseFragment @Inject constructor(
// .colorizeMatchingText(key, colorProvider.getColorFromAttribute(android.R.attr.textColorLink))
views.ssssPassphraseEnterEdittext.editorActionEvents()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
if (it.actionId == EditorInfo.IME_ACTION_DONE) {
submit()
}
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssPassphraseEnterEdittext.textChanges()
- .subscribe {
+ .onEach {
views.ssssPassphraseEnterTil.error = null
views.ssssPassphraseSubmit.isEnabled = it.isNotBlank()
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssPassphraseReset.views.bottomSheetActionClickableZone.debouncedClicks {
sharedViewModel.handle(SharedSecureStorageAction.ForgotResetAll)
diff --git a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageResetAllFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageResetAllFragment.kt
index 670e5c610a..200b2b73c2 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageResetAllFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/quads/SharedSecuredStorageResetAllFragment.kt
@@ -55,7 +55,7 @@ class SharedSecuredStorageResetAllFragment @Inject constructor() :
}
}
- sharedViewModel.subscribe(this) { state ->
+ sharedViewModel.onEach { state ->
views.ssssResetOtherDevices.setTextOrHide(
state.activeDeviceCount
.takeIf { it > 0 }
diff --git a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapConfirmPassphraseFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapConfirmPassphraseFragment.kt
index 4aeb822bbd..940a4d9af3 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapConfirmPassphraseFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapConfirmPassphraseFragment.kt
@@ -22,16 +22,18 @@ import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import androidx.core.view.isGone
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.parentFragmentViewModel
import com.airbnb.mvrx.withState
-import com.jakewharton.rxbinding3.widget.editorActionEvents
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.hideKeyboard
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.databinding.FragmentBootstrapEnterPassphraseBinding
-import io.reactivex.android.schedulers.AndroidSchedulers
-import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.widget.editorActionEvents
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class BootstrapConfirmPassphraseFragment @Inject constructor() :
@@ -58,21 +60,20 @@ class BootstrapConfirmPassphraseFragment @Inject constructor() :
}
views.ssssPassphraseEnterEdittext.editorActionEvents()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
if (it.actionId == EditorInfo.IME_ACTION_DONE) {
submit()
}
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssPassphraseEnterEdittext.textChanges()
- .subscribe {
+ .onEach {
views.ssssPassphraseEnterTil.error = null
- sharedViewModel.handle(BootstrapActions.UpdateConfirmCandidatePassphrase(it?.toString() ?: ""))
+ sharedViewModel.handle(BootstrapActions.UpdateConfirmCandidatePassphrase(it.toString()))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
sharedViewModel.observeViewEvents {
// when (it) {
diff --git a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapEnterPassphraseFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapEnterPassphraseFragment.kt
index f43ddb8888..77fb5ab3a6 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapEnterPassphraseFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapEnterPassphraseFragment.kt
@@ -21,16 +21,18 @@ import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.parentFragmentViewModel
import com.airbnb.mvrx.withState
-import com.jakewharton.rxbinding3.widget.editorActionEvents
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.databinding.FragmentBootstrapEnterPassphraseBinding
import im.vector.app.features.settings.VectorLocale
-import io.reactivex.android.schedulers.AndroidSchedulers
-import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.widget.editorActionEvents
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class BootstrapEnterPassphraseFragment @Inject constructor() :
@@ -53,22 +55,21 @@ class BootstrapEnterPassphraseFragment @Inject constructor() :
views.ssssPassphraseEnterEdittext.setText(it.passphrase ?: "")
}
views.ssssPassphraseEnterEdittext.editorActionEvents()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
if (it.actionId == EditorInfo.IME_ACTION_DONE) {
submit()
}
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.ssssPassphraseEnterEdittext.textChanges()
- .subscribe {
+ .onEach {
// ssss_passphrase_enter_til.error = null
- sharedViewModel.handle(BootstrapActions.UpdateCandidatePassphrase(it?.toString() ?: ""))
+ sharedViewModel.handle(BootstrapActions.UpdateCandidatePassphrase(it.toString()))
// ssss_passphrase_submit.isEnabled = it.isNotBlank()
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
sharedViewModel.observeViewEvents {
// when (it) {
diff --git a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapMigrateBackupFragment.kt b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapMigrateBackupFragment.kt
index b40a194a15..5d0f3bbeae 100644
--- a/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapMigrateBackupFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapMigrateBackupFragment.kt
@@ -27,22 +27,24 @@ import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import androidx.core.text.toSpannable
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.parentFragmentViewModel
import com.airbnb.mvrx.withState
-import com.jakewharton.rxbinding3.widget.editorActionEvents
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.extensions.registerStartForActivityResult
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.core.resources.ColorProvider
import im.vector.app.core.utils.colorizeMatchingText
import im.vector.app.core.utils.startImportTextFromFileIntent
import im.vector.app.databinding.FragmentBootstrapMigrateBackupBinding
-import io.reactivex.android.schedulers.AndroidSchedulers
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.internal.crypto.keysbackup.util.isValidRecoveryKey
-import java.util.concurrent.TimeUnit
+import reactivecircus.flowbinding.android.widget.editorActionEvents
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class BootstrapMigrateBackupFragment @Inject constructor(
@@ -63,22 +65,21 @@ class BootstrapMigrateBackupFragment @Inject constructor(
views.bootstrapMigrateEditText.setText(it.passphrase ?: "")
}
views.bootstrapMigrateEditText.editorActionEvents()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
if (it.actionId == EditorInfo.IME_ACTION_DONE) {
submit()
}
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.bootstrapMigrateEditText.textChanges()
.skipInitialValue()
- .subscribe {
+ .onEach {
views.bootstrapRecoveryKeyEnterTil.error = null
// sharedViewModel.handle(BootstrapActions.UpdateCandidatePassphrase(it?.toString() ?: ""))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
// sharedViewModel.observeViewEvents {}
views.bootstrapMigrateContinueButton.debouncedClicks { submit() }
diff --git a/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolActivity.kt b/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolActivity.kt
index 772ef99931..2c7a15e6ad 100644
--- a/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolActivity.kt
@@ -66,7 +66,7 @@ class RoomDevToolActivity : SimpleFragmentActivity(), FragmentManager.OnBackStac
override fun initUiAndData() {
super.initUiAndData()
- viewModel.subscribe(this) {
+ viewModel.onEach {
renderState(it)
}
diff --git a/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolEditFragment.kt b/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolEditFragment.kt
index 9af51f67b3..dd0bd174af 100644
--- a/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolEditFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/devtools/RoomDevToolEditFragment.kt
@@ -20,12 +20,15 @@ import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.activityViewModel
import com.airbnb.mvrx.withState
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.platform.VectorBaseFragment
import im.vector.app.databinding.FragmentDevtoolsEditorBinding
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class RoomDevToolEditFragment @Inject constructor() :
@@ -44,10 +47,10 @@ class RoomDevToolEditFragment @Inject constructor() :
}
views.editText.textChanges()
.skipInitialValue()
- .subscribe {
+ .onEach {
sharedViewModel.handle(RoomDevToolAction.UpdateContentText(it.toString()))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
override fun onResume() {
diff --git a/vector/src/main/java/im/vector/app/features/discovery/DiscoverySettingsController.kt b/vector/src/main/java/im/vector/app/features/discovery/DiscoverySettingsController.kt
index d8c67592f1..03c5d981cb 100644
--- a/vector/src/main/java/im/vector/app/features/discovery/DiscoverySettingsController.kt
+++ b/vector/src/main/java/im/vector/app/features/discovery/DiscoverySettingsController.kt
@@ -95,7 +95,7 @@ class DiscoverySettingsController @Inject constructor(
} else {
settingsInfoItem {
id("idConsentInfo")
- helperTextResId(R.string.settings_discovery_consent_notice_off)
+ helperTextResId(R.string.settings_discovery_consent_notice_off_2)
}
settingsButtonItem {
id("idConsentButton")
diff --git a/vector/src/main/java/im/vector/app/features/discovery/change/SetIdentityServerFragment.kt b/vector/src/main/java/im/vector/app/features/discovery/change/SetIdentityServerFragment.kt
index 15e4e65d3b..fcea2e92b1 100644
--- a/vector/src/main/java/im/vector/app/features/discovery/change/SetIdentityServerFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/discovery/change/SetIdentityServerFragment.kt
@@ -24,10 +24,10 @@ import android.view.inputmethod.EditorInfo
import androidx.appcompat.app.AppCompatActivity
import androidx.core.text.toSpannable
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.fragmentViewModel
import com.airbnb.mvrx.withState
import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.exhaustive
import im.vector.app.core.extensions.registerStartForActivityResult
@@ -37,7 +37,10 @@ import im.vector.app.core.resources.ColorProvider
import im.vector.app.core.utils.colorizeMatchingText
import im.vector.app.databinding.FragmentSetIdentityServerBinding
import im.vector.app.features.discovery.DiscoverySharedViewModel
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.session.terms.TermsService
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
class SetIdentityServerFragment @Inject constructor(
@@ -90,11 +93,11 @@ class SetIdentityServerFragment @Inject constructor(
views.identityServerSetDefaultAlternativeTextInput
.textChanges()
- .subscribe {
+ .onEach {
views.identityServerSetDefaultAlternativeTil.error = null
views.identityServerSetDefaultAlternativeSubmit.isEnabled = it.isNotEmpty()
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.identityServerSetDefaultSubmit.debouncedClicks {
viewModel.handle(SetIdentityServerAction.UseDefaultIdentityServer)
diff --git a/vector/src/main/java/im/vector/app/features/form/FormEditTextWithDeleteItem.kt b/vector/src/main/java/im/vector/app/features/form/FormEditTextWithDeleteItem.kt
new file mode 100644
index 0000000000..abcd1429d4
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/features/form/FormEditTextWithDeleteItem.kt
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021 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.app.features.form
+
+import android.text.Editable
+import android.view.inputmethod.EditorInfo
+import android.widget.ImageButton
+import com.airbnb.epoxy.EpoxyAttribute
+import com.airbnb.epoxy.EpoxyModelClass
+import com.google.android.material.textfield.TextInputEditText
+import com.google.android.material.textfield.TextInputLayout
+import im.vector.app.R
+import im.vector.app.core.epoxy.ClickListener
+import im.vector.app.core.epoxy.TextListener
+import im.vector.app.core.epoxy.VectorEpoxyHolder
+import im.vector.app.core.epoxy.VectorEpoxyModel
+import im.vector.app.core.epoxy.addTextChangedListenerOnce
+import im.vector.app.core.epoxy.onClick
+import im.vector.app.core.extensions.setTextIfDifferent
+import im.vector.app.core.platform.SimpleTextWatcher
+
+@EpoxyModelClass(layout = R.layout.item_form_text_input_with_delete)
+abstract class FormEditTextWithDeleteItem : VectorEpoxyModel() {
+
+ @EpoxyAttribute
+ var hint: String? = null
+
+ @EpoxyAttribute
+ var value: String? = null
+
+ @EpoxyAttribute
+ var enabled: Boolean = true
+
+ @EpoxyAttribute
+ var singleLine: Boolean = true
+
+ @EpoxyAttribute
+ var imeOptions: Int? = null
+
+ @EpoxyAttribute(EpoxyAttribute.Option.DoNotHash)
+ var onTextChange: TextListener? = null
+
+ @EpoxyAttribute(EpoxyAttribute.Option.DoNotHash)
+ var onDeleteClicked: ClickListener? = null
+
+ private val onTextChangeListener = object : SimpleTextWatcher() {
+ override fun afterTextChanged(s: Editable) {
+ onTextChange?.invoke(s.toString())
+ }
+ }
+
+ override fun bind(holder: Holder) {
+ super.bind(holder)
+ holder.textInputLayout.isEnabled = enabled
+ holder.textInputLayout.hint = hint
+
+ holder.textInputEditText.setTextIfDifferent(value)
+
+ holder.textInputEditText.isEnabled = enabled
+ holder.textInputEditText.isSingleLine = singleLine
+
+ holder.textInputEditText.imeOptions =
+ imeOptions ?: when (singleLine) {
+ true -> EditorInfo.IME_ACTION_NEXT
+ false -> EditorInfo.IME_ACTION_NONE
+ }
+
+ holder.textInputEditText.addTextChangedListenerOnce(onTextChangeListener)
+
+ holder.textInputDeleteButton.onClick(onDeleteClicked)
+ }
+
+ override fun shouldSaveViewState(): Boolean {
+ return false
+ }
+
+ override fun unbind(holder: Holder) {
+ super.unbind(holder)
+ holder.textInputEditText.removeTextChangedListener(onTextChangeListener)
+ }
+
+ class Holder : VectorEpoxyHolder() {
+ val textInputLayout by bind(R.id.formTextInputTextInputLayout)
+ val textInputEditText by bind(R.id.formTextInputTextInputEditText)
+ val textInputDeleteButton by bind(R.id.formTextInputDeleteButton)
+ }
+}
diff --git a/vector/src/main/java/im/vector/app/features/home/HomeActivity.kt b/vector/src/main/java/im/vector/app/features/home/HomeActivity.kt
index 1ad08ac8e9..16c0655d85 100644
--- a/vector/src/main/java/im/vector/app/features/home/HomeActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/home/HomeActivity.kt
@@ -73,6 +73,8 @@ import im.vector.app.features.spaces.share.ShareSpaceBottomSheet
import im.vector.app.features.themes.ThemeUtils
import im.vector.app.features.workers.signout.ServerBackupStatusViewModel
import im.vector.app.push.fcm.FcmHelper
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import kotlinx.parcelize.Parcelize
import org.matrix.android.sdk.api.session.initsync.SyncStatusService
@@ -178,8 +180,8 @@ class HomeActivity :
}
sharedActionViewModel
- .observe()
- .subscribe { sharedAction ->
+ .stream()
+ .onEach { sharedAction ->
when (sharedAction) {
is HomeActivitySharedAction.OpenDrawer -> views.drawerLayout.openDrawer(GravityCompat.START)
is HomeActivitySharedAction.CloseDrawer -> views.drawerLayout.closeDrawer(GravityCompat.START)
@@ -222,7 +224,7 @@ class HomeActivity :
}
}.exhaustive
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
val args = intent.getParcelableExtra(Mavericks.KEY_ARG)
@@ -243,13 +245,12 @@ class HomeActivity :
is HomeActivityViewEvents.OnCrossSignedInvalidated -> handleCrossSigningInvalidated(it)
}.exhaustive
}
- homeActivityViewModel.subscribe(this) { renderState(it) }
+ homeActivityViewModel.onEach { renderState(it) }
- shortcutsHandler.observeRoomsAndBuildShortcuts()
- .disposeOnDestroy()
+ shortcutsHandler.observeRoomsAndBuildShortcuts(lifecycleScope)
if (!vectorPreferences.didPromoteNewRestrictedFeature()) {
- promoteRestrictedViewModel.subscribe(this) {
+ promoteRestrictedViewModel.onEach {
if (it.activeSpaceSummary != null && !it.activeSpaceSummary.isPublic &&
it.activeSpaceSummary.otherMemberIds.isNotEmpty()) {
// It's a private space with some members show this once
diff --git a/vector/src/main/java/im/vector/app/features/home/HomeDetailFragment.kt b/vector/src/main/java/im/vector/app/features/home/HomeDetailFragment.kt
index 80351a437e..55d8e2e09a 100644
--- a/vector/src/main/java/im/vector/app/features/home/HomeDetailFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/home/HomeDetailFragment.kt
@@ -299,7 +299,7 @@ class HomeDetailFragment @Inject constructor(
private fun setupKeysBackupBanner() {
serverBackupStatusViewModel
- .subscribe(this) {
+ .onEach {
when (val banState = it.bannerState.invoke()) {
is BannerState.Setup -> views.homeKeysBackupBanner.render(KeysBackupBanner.State.Setup(banState.numberOfKeys), false)
BannerState.BackingUp -> views.homeKeysBackupBanner.render(KeysBackupBanner.State.BackingUp, false)
diff --git a/vector/src/main/java/im/vector/app/features/home/HomeDetailViewModel.kt b/vector/src/main/java/im/vector/app/features/home/HomeDetailViewModel.kt
index 73e50ad5f1..1c1d012cc8 100644
--- a/vector/src/main/java/im/vector/app/features/home/HomeDetailViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/HomeDetailViewModel.kt
@@ -27,6 +27,7 @@ import im.vector.app.RoomGroupingMethod
import im.vector.app.core.di.MavericksAssistedViewModelFactory
import im.vector.app.core.di.hiltMavericksViewModelFactory
import im.vector.app.core.extensions.singletonEntryPoint
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.VectorViewModel
import im.vector.app.features.call.dialpad.DialPadLookup
import im.vector.app.features.call.lookup.CallProtocolsChecker
@@ -36,10 +37,13 @@ import im.vector.app.features.invite.AutoAcceptInvites
import im.vector.app.features.invite.showInvites
import im.vector.app.features.settings.VectorDataStore
import im.vector.app.features.ui.UiStateRepository
-import io.reactivex.schedulers.Schedulers
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import org.matrix.android.sdk.api.query.ActiveSpaceFilter
import org.matrix.android.sdk.api.query.RoomCategoryFilter
@@ -50,9 +54,7 @@ import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams
import org.matrix.android.sdk.api.util.toMatrixItem
import org.matrix.android.sdk.flow.flow
-import org.matrix.android.sdk.rx.asObservable
import timber.log.Timber
-import java.util.concurrent.TimeUnit
/**
* View model used to update the home bottom bar notification counts, observe the sync state and
@@ -66,7 +68,7 @@ class HomeDetailViewModel @AssistedInject constructor(@Assisted initialState: Ho
private val directRoomHelper: DirectRoomHelper,
private val appStateHandler: AppStateHandler,
private val autoAcceptInvites: AutoAcceptInvites) :
- VectorViewModel(initialState),
+ VectorViewModel(initialState),
CallProtocolsChecker.Listener {
@AssistedFactory
@@ -194,18 +196,15 @@ class HomeDetailViewModel @AssistedInject constructor(@Assisted initialState: Ho
private fun observeRoomGroupingMethod() {
appStateHandler.selectedRoomGroupingObservable
- .subscribe {
- setState {
- copy(
- roomGroupingMethod = it.orNull() ?: RoomGroupingMethod.BySpace(null)
- )
- }
+ .setOnEach {
+ copy(
+ roomGroupingMethod = it.orNull() ?: RoomGroupingMethod.BySpace(null)
+ )
}
- .disposeOnClear()
}
private fun observeRoomSummaries() {
- appStateHandler.selectedRoomGroupingObservable.distinctUntilChanged().switchMap {
+ appStateHandler.selectedRoomGroupingObservable.distinctUntilChanged().flatMapLatest {
// we use it as a trigger to all changes in room, but do not really load
// the actual models
session.getPagedRoomSummariesLive(
@@ -213,11 +212,10 @@ class HomeDetailViewModel @AssistedInject constructor(@Assisted initialState: Ho
memberships = Membership.activeMemberships()
},
sortOrder = RoomSortOrder.NONE
- ).asObservable()
+ ).asFlow()
}
- .observeOn(Schedulers.computation())
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .subscribe {
+ .throttleFirst(300)
+ .onEach {
when (val groupingMethod = appStateHandler.getCurrentRoomGroupingMethod()) {
is RoomGroupingMethod.ByLegacyGroup -> {
// TODO!!
@@ -274,6 +272,6 @@ class HomeDetailViewModel @AssistedInject constructor(@Assisted initialState: Ho
}
}
}
- .disposeOnClear()
+ .launchIn(viewModelScope)
}
}
diff --git a/vector/src/main/java/im/vector/app/features/home/PromoteRestrictedViewModel.kt b/vector/src/main/java/im/vector/app/features/home/PromoteRestrictedViewModel.kt
index 218574c03e..77ee23f732 100644
--- a/vector/src/main/java/im/vector/app/features/home/PromoteRestrictedViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/PromoteRestrictedViewModel.kt
@@ -29,6 +29,7 @@ import im.vector.app.core.di.hiltMavericksViewModelFactory
import im.vector.app.core.platform.EmptyAction
import im.vector.app.core.platform.EmptyViewEvents
import im.vector.app.core.platform.VectorViewModel
+import kotlinx.coroutines.flow.distinctUntilChanged
import org.matrix.android.sdk.api.query.QueryStringValue
import org.matrix.android.sdk.api.session.events.model.EventType
import org.matrix.android.sdk.api.session.events.model.toModel
diff --git a/vector/src/main/java/im/vector/app/features/home/ShortcutsHandler.kt b/vector/src/main/java/im/vector/app/features/home/ShortcutsHandler.kt
index e63d8cf5b2..7622c8b5de 100644
--- a/vector/src/main/java/im/vector/app/features/home/ShortcutsHandler.kt
+++ b/vector/src/main/java/im/vector/app/features/home/ShortcutsHandler.kt
@@ -21,59 +21,70 @@ import android.content.pm.ShortcutManager
import android.os.Build
import androidx.core.content.getSystemService
import androidx.core.content.pm.ShortcutManagerCompat
+import im.vector.app.R
import im.vector.app.core.di.ActiveSessionHolder
+import im.vector.app.core.dispatchers.CoroutineDispatchers
+import im.vector.app.core.resources.StringProvider
import im.vector.app.features.pin.PinCodeStore
import im.vector.app.features.pin.PinCodeStoreListener
-import io.reactivex.disposables.Disposable
-import io.reactivex.disposables.Disposables
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
import org.matrix.android.sdk.api.session.room.RoomSortOrder
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.model.RoomSummary
import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams
-import org.matrix.android.sdk.rx.asObservable
+import org.matrix.android.sdk.flow.flow
import timber.log.Timber
+import java.util.concurrent.atomic.AtomicBoolean
import javax.inject.Inject
class ShortcutsHandler @Inject constructor(
private val context: Context,
+ private val stringProvider: StringProvider,
+ private val appDispatchers: CoroutineDispatchers,
private val shortcutCreator: ShortcutCreator,
private val activeSessionHolder: ActiveSessionHolder,
private val pinCodeStore: PinCodeStore
) : PinCodeStoreListener {
+
private val isRequestPinShortcutSupported = ShortcutManagerCompat.isRequestPinShortcutSupported(context)
private val maxShortcutCountPerActivity = ShortcutManagerCompat.getMaxShortcutCountPerActivity(context)
// Value will be set correctly if necessary
- private var hasPinCode = true
+ private var hasPinCode = AtomicBoolean(true)
- fun observeRoomsAndBuildShortcuts(): Disposable {
+ fun observeRoomsAndBuildShortcuts(coroutineScope: CoroutineScope): Job {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
// No op
- return Disposables.empty()
+ return Job()
}
-
- hasPinCode = pinCodeStore.getEncodedPin() != null
-
- val session = activeSessionHolder.getSafeActiveSession() ?: return Disposables.empty()
- return session.getRoomSummariesLive(
+ hasPinCode.set(pinCodeStore.getEncodedPin() != null)
+ val session = activeSessionHolder.getSafeActiveSession() ?: return Job()
+ return session.flow().liveRoomSummaries(
roomSummaryQueryParams {
memberships = listOf(Membership.JOIN)
},
sortOrder = RoomSortOrder.PRIORITY_AND_ACTIVITY
)
- .asObservable()
- .doOnSubscribe { pinCodeStore.addListener(this) }
- .doFinally { pinCodeStore.removeListener(this) }
- .subscribe { rooms ->
+ .onStart { pinCodeStore.addListener(this@ShortcutsHandler) }
+ .onCompletion { pinCodeStore.removeListener(this@ShortcutsHandler) }
+ .onEach { rooms ->
// Remove dead shortcuts (i.e. deleted rooms)
- removeDeadShortcut(rooms.map { it.roomId })
+ removeDeadShortcuts(rooms.map { it.roomId })
// Create shortcuts
createShortcuts(rooms)
}
+ .flowOn(appDispatchers.computation)
+ .launchIn(coroutineScope)
}
- private fun removeDeadShortcut(roomIds: List) {
+ private fun removeDeadShortcuts(roomIds: List) {
val deadShortcutIds = ShortcutManagerCompat.getShortcuts(context, ShortcutManagerCompat.FLAG_MATCH_DYNAMIC)
.map { it.id }
.filter { !roomIds.contains(it) }
@@ -83,14 +94,18 @@ class ShortcutsHandler @Inject constructor(
ShortcutManagerCompat.removeLongLivedShortcuts(context, deadShortcutIds)
if (isRequestPinShortcutSupported) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
- context.getSystemService()?.disableShortcuts(deadShortcutIds)
+ ShortcutManagerCompat.disableShortcuts(
+ context,
+ deadShortcutIds,
+ stringProvider.getString(R.string.shortcut_disabled_reason_room_left)
+ )
}
}
}
}
private fun createShortcuts(rooms: List) {
- if (hasPinCode) {
+ if (hasPinCode.get()) {
// No shortcut in this case (privacy)
ShortcutManagerCompat.removeAllDynamicShortcuts(context)
} else {
@@ -122,15 +137,22 @@ class ShortcutsHandler @Inject constructor(
if (isRequestPinShortcutSupported) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
context.getSystemService()
- ?.let {
- it.disableShortcuts(it.pinnedShortcuts.map { pinnedShortcut -> pinnedShortcut.id })
+ ?.pinnedShortcuts
+ ?.takeIf { it.isNotEmpty() }
+ ?.map { pinnedShortcut -> pinnedShortcut.id }
+ ?.let { shortcutIdsToDisable ->
+ ShortcutManagerCompat.disableShortcuts(
+ context,
+ shortcutIdsToDisable,
+ stringProvider.getString(R.string.shortcut_disabled_reason_sign_out)
+ )
}
}
}
}
override fun onPinSetUpChange(isConfigured: Boolean) {
- hasPinCode = isConfigured
+ hasPinCode.set(isConfigured)
if (isConfigured) {
// Remove shortcuts immediately
ShortcutManagerCompat.removeAllDynamicShortcuts(context)
diff --git a/vector/src/main/java/im/vector/app/features/home/UnreadMessagesSharedViewModel.kt b/vector/src/main/java/im/vector/app/features/home/UnreadMessagesSharedViewModel.kt
index 5bdbc95b48..6c0ae71cfa 100644
--- a/vector/src/main/java/im/vector/app/features/home/UnreadMessagesSharedViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/UnreadMessagesSharedViewModel.kt
@@ -16,6 +16,7 @@
package im.vector.app.features.home
+import androidx.lifecycle.asFlow
import com.airbnb.mvrx.MavericksState
import com.airbnb.mvrx.MavericksViewModelFactory
import dagger.assisted.Assisted
@@ -25,13 +26,17 @@ import im.vector.app.AppStateHandler
import im.vector.app.RoomGroupingMethod
import im.vector.app.core.di.MavericksAssistedViewModelFactory
import im.vector.app.core.di.hiltMavericksViewModelFactory
+import im.vector.app.core.flow.throttleFirst
import im.vector.app.core.platform.EmptyAction
import im.vector.app.core.platform.EmptyViewEvents
import im.vector.app.core.platform.VectorViewModel
import im.vector.app.features.invite.AutoAcceptInvites
import im.vector.app.features.settings.VectorPreferences
-import io.reactivex.Observable
-import io.reactivex.schedulers.Schedulers
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
import org.matrix.android.sdk.api.query.ActiveSpaceFilter
import org.matrix.android.sdk.api.session.Session
import org.matrix.android.sdk.api.session.room.RoomSortOrder
@@ -39,8 +44,6 @@ import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams
import org.matrix.android.sdk.api.session.room.spaceSummaryQueryParams
import org.matrix.android.sdk.api.session.room.summary.RoomAggregateNotificationCount
-import org.matrix.android.sdk.rx.asObservable
-import java.util.concurrent.TimeUnit
data class UnreadMessagesState(
val homeSpaceUnread: RoomAggregateNotificationCount = RoomAggregateNotificationCount(0, 0),
@@ -57,7 +60,7 @@ class UnreadMessagesSharedViewModel @AssistedInject constructor(@Assisted initia
private val vectorPreferences: VectorPreferences,
appStateHandler: AppStateHandler,
private val autoAcceptInvites: AutoAcceptInvites) :
- VectorViewModel(initialState) {
+ VectorViewModel(initialState) {
@AssistedFactory
interface Factory : MavericksAssistedViewModelFactory {
@@ -75,8 +78,8 @@ class UnreadMessagesSharedViewModel @AssistedInject constructor(@Assisted initia
this.memberships = listOf(Membership.JOIN)
this.activeSpaceFilter = ActiveSpaceFilter.ActiveSpace(null)
}, sortOrder = RoomSortOrder.NONE
- ).asObservable()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
+ ).asFlow()
+ .throttleFirst(300)
.execute {
val counts = session.getNotificationCountForRooms(
roomSummaryQueryParams {
@@ -103,91 +106,91 @@ class UnreadMessagesSharedViewModel @AssistedInject constructor(@Assisted initia
)
}
- Observable.combineLatest(
+ combine(
appStateHandler.selectedRoomGroupingObservable.distinctUntilChanged(),
- appStateHandler.selectedRoomGroupingObservable.switchMap {
+ appStateHandler.selectedRoomGroupingObservable.flatMapLatest {
session.getPagedRoomSummariesLive(
roomSummaryQueryParams {
this.memberships = Membership.activeMemberships()
}, sortOrder = RoomSortOrder.NONE
- ).asObservable()
- .throttleFirst(300, TimeUnit.MILLISECONDS)
- .observeOn(Schedulers.computation())
- },
- { groupingMethod, _ ->
- when (groupingMethod.orNull()) {
- is RoomGroupingMethod.ByLegacyGroup -> {
- // currently not supported
- CountInfo(
- RoomAggregateNotificationCount(0, 0),
- RoomAggregateNotificationCount(0, 0)
- )
- }
- is RoomGroupingMethod.BySpace -> {
- val selectedSpace = appStateHandler.safeActiveSpaceId()
-
- val inviteCount = if (autoAcceptInvites.hideInvites) {
- 0
- } else {
- session.getRoomSummaries(
- roomSummaryQueryParams { this.memberships = listOf(Membership.INVITE) }
- ).size
- }
-
- val spaceInviteCount = if (autoAcceptInvites.hideInvites) {
- 0
- } else {
- session.getRoomSummaries(
- spaceSummaryQueryParams {
- this.memberships = listOf(Membership.INVITE)
- }
- ).size
- }
-
- val totalCount = session.getNotificationCountForRooms(
- roomSummaryQueryParams {
- this.memberships = listOf(Membership.JOIN)
- this.activeSpaceFilter = ActiveSpaceFilter.ActiveSpace(null).takeIf {
- !vectorPreferences.prefSpacesShowAllRoomInHome()
- } ?: ActiveSpaceFilter.None
- }
- )
-
- val counts = RoomAggregateNotificationCount(
- totalCount.notificationCount + inviteCount,
- totalCount.highlightCount + inviteCount
- )
- val rootCounts = session.spaceService().getRootSpaceSummaries()
- .filter {
- // filter out current selection
- it.roomId != selectedSpace
- }
-
- CountInfo(
- homeCount = counts,
- otherCount = RoomAggregateNotificationCount(
- notificationCount = rootCounts.fold(0, { acc, rs -> acc + rs.notificationCount }) +
- (counts.notificationCount.takeIf { selectedSpace != null } ?: 0) +
- spaceInviteCount,
- highlightCount = rootCounts.fold(0, { acc, rs -> acc + rs.highlightCount }) +
- (counts.highlightCount.takeIf { selectedSpace != null } ?: 0) +
- spaceInviteCount
- )
- )
- }
- null -> {
- CountInfo(
- RoomAggregateNotificationCount(0, 0),
- RoomAggregateNotificationCount(0, 0)
- )
- }
- }
+ ).asFlow()
+ .throttleFirst(300)
}
- ).execute {
- copy(
- homeSpaceUnread = it.invoke()?.homeCount ?: RoomAggregateNotificationCount(0, 0),
- otherSpacesUnread = it.invoke()?.otherCount ?: RoomAggregateNotificationCount(0, 0)
- )
+ ) { groupingMethod, _ ->
+ when (groupingMethod.orNull()) {
+ is RoomGroupingMethod.ByLegacyGroup -> {
+ // currently not supported
+ CountInfo(
+ RoomAggregateNotificationCount(0, 0),
+ RoomAggregateNotificationCount(0, 0)
+ )
+ }
+ is RoomGroupingMethod.BySpace -> {
+ val selectedSpace = appStateHandler.safeActiveSpaceId()
+
+ val inviteCount = if (autoAcceptInvites.hideInvites) {
+ 0
+ } else {
+ session.getRoomSummaries(
+ roomSummaryQueryParams { this.memberships = listOf(Membership.INVITE) }
+ ).size
+ }
+
+ val spaceInviteCount = if (autoAcceptInvites.hideInvites) {
+ 0
+ } else {
+ session.getRoomSummaries(
+ spaceSummaryQueryParams {
+ this.memberships = listOf(Membership.INVITE)
+ }
+ ).size
+ }
+
+ val totalCount = session.getNotificationCountForRooms(
+ roomSummaryQueryParams {
+ this.memberships = listOf(Membership.JOIN)
+ this.activeSpaceFilter = ActiveSpaceFilter.ActiveSpace(null).takeIf {
+ !vectorPreferences.prefSpacesShowAllRoomInHome()
+ } ?: ActiveSpaceFilter.None
+ }
+ )
+
+ val counts = RoomAggregateNotificationCount(
+ totalCount.notificationCount + inviteCount,
+ totalCount.highlightCount + inviteCount
+ )
+ val rootCounts = session.spaceService().getRootSpaceSummaries()
+ .filter {
+ // filter out current selection
+ it.roomId != selectedSpace
+ }
+
+ CountInfo(
+ homeCount = counts,
+ otherCount = RoomAggregateNotificationCount(
+ notificationCount = rootCounts.fold(0, { acc, rs -> acc + rs.notificationCount }) +
+ (counts.notificationCount.takeIf { selectedSpace != null } ?: 0) +
+ spaceInviteCount,
+ highlightCount = rootCounts.fold(0, { acc, rs -> acc + rs.highlightCount }) +
+ (counts.highlightCount.takeIf { selectedSpace != null } ?: 0) +
+ spaceInviteCount
+ )
+ )
+ }
+ null -> {
+ CountInfo(
+ RoomAggregateNotificationCount(0, 0),
+ RoomAggregateNotificationCount(0, 0)
+ )
+ }
+ }
}
+ .flowOn(Dispatchers.Default)
+ .execute {
+ copy(
+ homeSpaceUnread = it.invoke()?.homeCount ?: RoomAggregateNotificationCount(0, 0),
+ otherSpacesUnread = it.invoke()?.otherCount ?: RoomAggregateNotificationCount(0, 0)
+ )
+ }
}
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailActivity.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailActivity.kt
index ba53f75eca..415ca7bc04 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailActivity.kt
@@ -24,6 +24,7 @@ import androidx.core.view.GravityCompat
import androidx.drawerlayout.widget.DrawerLayout
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.Mavericks
import com.airbnb.mvrx.viewModel
import com.google.android.material.appbar.MaterialToolbar
@@ -40,6 +41,8 @@ import im.vector.app.features.navigation.Navigator
import im.vector.app.features.room.RequireActiveMembershipAction
import im.vector.app.features.room.RequireActiveMembershipViewEvents
import im.vector.app.features.room.RequireActiveMembershipViewModel
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
@AndroidEntryPoint
class RoomDetailActivity :
@@ -97,13 +100,13 @@ class RoomDetailActivity :
sharedActionViewModel = viewModelProvider.get(RoomDetailSharedActionViewModel::class.java)
sharedActionViewModel
- .observe()
- .subscribe { sharedAction ->
+ .stream()
+ .onEach { sharedAction ->
when (sharedAction) {
is RoomDetailSharedAction.SwitchToRoom -> switchToRoom(sharedAction)
}
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
requireActiveMembershipViewModel.observeViewEvents {
when (it) {
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailFragment.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailFragment.kt
index 75edee5d55..f0d7c6157e 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailFragment.kt
@@ -67,8 +67,6 @@ import com.airbnb.mvrx.args
import com.airbnb.mvrx.fragmentViewModel
import com.airbnb.mvrx.withState
import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.jakewharton.rxbinding3.view.focusChanges
-import com.jakewharton.rxbinding3.widget.textChanges
import com.vanniktech.emoji.EmojiPopup
import im.vector.app.R
import im.vector.app.core.dialogs.ConfirmationDialogBuilder
@@ -185,6 +183,10 @@ import im.vector.app.features.widgets.WidgetActivity
import im.vector.app.features.widgets.WidgetArgs
import im.vector.app.features.widgets.WidgetKind
import im.vector.app.features.widgets.permissions.RoomWidgetPermissionBottomSheet
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import kotlinx.parcelize.Parcelize
import nl.dionsegijn.konfetti.models.Shape
@@ -216,10 +218,11 @@ import org.matrix.android.sdk.api.util.MimeTypes
import org.matrix.android.sdk.api.util.toMatrixItem
import org.matrix.android.sdk.internal.crypto.model.event.EncryptedEventContent
import org.matrix.android.sdk.internal.crypto.model.event.WithHeldCode
+import reactivecircus.flowbinding.android.view.focusChanges
+import reactivecircus.flowbinding.android.widget.textChanges
import timber.log.Timber
import java.net.URL
import java.util.UUID
-import java.util.concurrent.TimeUnit
import javax.inject.Inject
@Parcelize
@@ -366,11 +369,11 @@ class RoomDetailFragment @Inject constructor(
}
sharedActionViewModel
- .observe()
- .subscribe {
+ .stream()
+ .onEach {
handleActions(it)
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
knownCallsViewModel
.liveKnownCalls
@@ -1358,19 +1361,19 @@ class RoomDetailFragment @Inject constructor(
private fun observerUserTyping() {
views.composerLayout.views.composerEditText.textChanges()
.skipInitialValue()
- .debounce(300, TimeUnit.MILLISECONDS)
+ .debounce(300)
.map { it.isNotEmpty() }
- .subscribe {
+ .onEach {
Timber.d("Typing: User is typing: $it")
textComposerViewModel.handle(TextComposerAction.UserIsTyping(it))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
views.composerLayout.views.composerEditText.focusChanges()
- .subscribe {
+ .onEach {
roomDetailViewModel.handle(RoomDetailAction.ComposerFocusChange(it))
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun sendUri(uri: Uri): Boolean {
@@ -2099,12 +2102,12 @@ class RoomDetailFragment @Inject constructor(
// VectorInviteView.Callback
override fun onAcceptInvite() {
- notificationDrawerManager.clearMemberShipNotificationForRoom(roomDetailArgs.roomId)
+ notificationDrawerManager.updateEvents { it.clearMemberShipNotificationForRoom(roomDetailArgs.roomId) }
roomDetailViewModel.handle(RoomDetailAction.AcceptInvite)
}
override fun onRejectInvite() {
- notificationDrawerManager.clearMemberShipNotificationForRoom(roomDetailArgs.roomId)
+ notificationDrawerManager.updateEvents { it.clearMemberShipNotificationForRoom(roomDetailArgs.roomId) }
roomDetailViewModel.handle(RoomDetailAction.RejectInvite)
}
@@ -2155,6 +2158,7 @@ class RoomDetailFragment @Inject constructor(
AttachmentTypeSelectorView.Type.AUDIO -> attachmentsHelper.selectAudio(attachmentAudioActivityResultLauncher)
AttachmentTypeSelectorView.Type.CONTACT -> attachmentsHelper.selectContact(attachmentContactActivityResultLauncher)
AttachmentTypeSelectorView.Type.STICKER -> roomDetailViewModel.handle(RoomDetailAction.SelectStickerAttachment)
+ AttachmentTypeSelectorView.Type.POLL -> navigator.openCreatePoll(requireContext(), roomDetailArgs.roomId)
}.exhaustive
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailViewModel.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailViewModel.kt
index 03bde7d4cc..d846a1d1f8 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/RoomDetailViewModel.kt
@@ -27,16 +27,17 @@ import com.airbnb.mvrx.MavericksViewModelFactory
import com.airbnb.mvrx.Success
import com.airbnb.mvrx.Uninitialized
import com.airbnb.mvrx.ViewModelContext
-import com.jakewharton.rxrelay2.BehaviorRelay
import dagger.assisted.Assisted
import dagger.assisted.AssistedFactory
import dagger.assisted.AssistedInject
import im.vector.app.BuildConfig
import im.vector.app.R
import im.vector.app.core.extensions.exhaustive
+import im.vector.app.core.flow.chunk
import im.vector.app.core.mvrx.runCatchingToAsync
import im.vector.app.core.platform.VectorViewModel
import im.vector.app.core.resources.StringProvider
+import im.vector.app.core.utils.BehaviorDataSource
import im.vector.app.features.attachments.toContentAttachmentData
import im.vector.app.features.call.conference.ConferenceEvent
import im.vector.app.features.call.conference.JitsiActiveConferenceHolder
@@ -56,13 +57,14 @@ import im.vector.app.features.session.coroutineScope
import im.vector.app.features.settings.VectorDataStore
import im.vector.app.features.settings.VectorPreferences
import im.vector.app.features.voice.VoicePlayerHelper
-import io.reactivex.rxkotlin.subscribeBy
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach
@@ -98,7 +100,6 @@ import org.matrix.android.sdk.flow.flow
import org.matrix.android.sdk.flow.unwrap
import org.matrix.android.sdk.internal.crypto.model.event.WithHeldCode
import timber.log.Timber
-import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
class RoomDetailViewModel @AssistedInject constructor(
@@ -123,8 +124,8 @@ class RoomDetailViewModel @AssistedInject constructor(
private val room = session.getRoom(initialState.roomId)!!
private val eventId = initialState.eventId
- private val invisibleEventsObservable = BehaviorRelay.create()
- private val visibleEventsObservable = BehaviorRelay.create()
+ private val invisibleEventsSource = BehaviorDataSource()
+ private val visibleEventsSource = BehaviorDataSource()
private var timelineEvents = MutableSharedFlow>(0)
val timeline = timelineFactory.createTimeline(viewModelScope, room, eventId)
@@ -562,7 +563,7 @@ class RoomDetailViewModel @AssistedInject constructor(
}
private fun handleEventInvisible(action: RoomDetailAction.TimelineEventTurnsInvisible) {
- invisibleEventsObservable.accept(action)
+ invisibleEventsSource.post(action)
}
fun getMember(userId: String): RoomMemberSummary? {
@@ -711,12 +712,12 @@ class RoomDetailViewModel @AssistedInject constructor(
private fun handleEventVisible(action: RoomDetailAction.TimelineEventTurnsVisible) {
viewModelScope.launch(Dispatchers.Default) {
if (action.event.root.sendState.isSent()) { // ignore pending/local events
- visibleEventsObservable.accept(action)
+ visibleEventsSource.post(action)
}
// We need to update this with the related m.replace also (to move read receipt)
action.event.annotations?.editSummary?.sourceEvents?.forEach {
room.getTimeLineEvent(it)?.let { event ->
- visibleEventsObservable.accept(RoomDetailAction.TimelineEventTurnsVisible(event))
+ visibleEventsSource.post(RoomDetailAction.TimelineEventTurnsVisible(event))
}
}
@@ -864,11 +865,13 @@ class RoomDetailViewModel @AssistedInject constructor(
private fun observeEventDisplayedActions() {
// We are buffering scroll events for one second
// and keep the most recent one to set the read receipt on.
- visibleEventsObservable
- .buffer(1, TimeUnit.SECONDS)
+
+ visibleEventsSource
+ .stream()
+ .chunk(1000)
.filter { it.isNotEmpty() }
- .subscribeBy(onNext = { actions ->
- val bufferedMostRecentDisplayedEvent = actions.maxByOrNull { it.event.displayIndex }?.event ?: return@subscribeBy
+ .onEach { actions ->
+ val bufferedMostRecentDisplayedEvent = actions.maxByOrNull { it.event.displayIndex }?.event ?: return@onEach
val globalMostRecentDisplayedEvent = mostRecentDisplayedEvent
if (trackUnreadMessages.get()) {
if (globalMostRecentDisplayedEvent == null) {
@@ -882,8 +885,9 @@ class RoomDetailViewModel @AssistedInject constructor(
tryOrNull { room.setReadReceipt(eventId) }
}
}
- })
- .disposeOnClear()
+ }
+ .flowOn(Dispatchers.Default)
+ .launchIn(viewModelScope)
}
private fun handleMarkAllAsRead() {
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/composer/ComposerEditText.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/composer/ComposerEditText.kt
index 232323789c..03107fd3f7 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/composer/ComposerEditText.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/composer/ComposerEditText.kt
@@ -17,13 +17,15 @@
package im.vector.app.features.home.room.detail.composer
+import android.content.ClipData
import android.content.Context
import android.net.Uri
-import android.os.Build
import android.text.Editable
import android.util.AttributeSet
import android.view.inputmethod.EditorInfo
import android.view.inputmethod.InputConnection
+import androidx.core.view.OnReceiveContentListener
+import androidx.core.view.ViewCompat
import androidx.core.view.inputmethod.EditorInfoCompat
import androidx.core.view.inputmethod.InputConnectionCompat
import com.vanniktech.emoji.EmojiEditText
@@ -33,7 +35,7 @@ import im.vector.app.features.html.PillImageSpan
import timber.log.Timber
class ComposerEditText @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = android.R.attr.editTextStyle) :
- EmojiEditText(context, attrs, defStyleAttr) {
+ EmojiEditText(context, attrs, defStyleAttr) {
interface Callback {
fun onRichContentSelected(contentUri: Uri): Boolean
@@ -43,23 +45,35 @@ class ComposerEditText @JvmOverloads constructor(context: Context, attrs: Attrib
var callback: Callback? = null
override fun onCreateInputConnection(editorInfo: EditorInfo): InputConnection? {
- val ic = super.onCreateInputConnection(editorInfo) ?: return null
- EditorInfoCompat.setContentMimeTypes(editorInfo, arrayOf("*/*"))
+ var ic = super.onCreateInputConnection(editorInfo) ?: return null
+ val mimeTypes = ViewCompat.getOnReceiveContentMimeTypes(this) ?: arrayOf("image/*")
- val callback =
- InputConnectionCompat.OnCommitContentListener { inputContentInfo, flags, _ ->
- val lacksPermission = (flags and
- InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1 && lacksPermission) {
- try {
- inputContentInfo.requestPermission()
- } catch (e: Exception) {
- return@OnCommitContentListener false
- }
- }
- callback?.onRichContentSelected(inputContentInfo.contentUri) ?: false
+ EditorInfoCompat.setContentMimeTypes(editorInfo, mimeTypes)
+ ic = InputConnectionCompat.createWrapper(this, ic, editorInfo)
+
+ val onReceiveContentListener = OnReceiveContentListener { _, payload ->
+ val split = payload.partition { item -> item.uri != null }
+ val uriContent = split.first
+ val remaining = split.second
+
+ if (uriContent != null) {
+ val clip: ClipData = uriContent.clip
+ for (i in 0 until clip.itemCount) {
+ val uri = clip.getItemAt(i).uri
+ // ... app-specific logic to handle the URI ...
+ callback?.onRichContentSelected(uri)
}
- return InputConnectionCompat.createWrapper(ic, editorInfo, callback)
+ }
+ // Return anything that we didn't handle ourselves. This preserves the default platform
+ // behavior for text and anything else for which we are not implementing custom handling.
+ // Return anything that we didn't handle ourselves. This preserves the default platform
+ // behavior for text and anything else for which we are not implementing custom handling.
+ remaining
+ }
+
+ ViewCompat.setOnReceiveContentListener(this, mimeTypes, onReceiveContentListener)
+
+ return ic
}
init {
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/composer/TextComposerViewModel.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/composer/TextComposerViewModel.kt
index e80f25de2f..66d49f9819 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/composer/TextComposerViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/composer/TextComposerViewModel.kt
@@ -47,7 +47,6 @@ import org.matrix.android.sdk.api.session.room.model.PowerLevelsContent
import org.matrix.android.sdk.api.session.room.model.RoomAvatarContent
import org.matrix.android.sdk.api.session.room.model.RoomMemberContent
import org.matrix.android.sdk.api.session.room.model.message.MessageType
-import org.matrix.android.sdk.api.session.room.model.message.OptionItem
import org.matrix.android.sdk.api.session.room.powerlevels.PowerLevelsHelper
import org.matrix.android.sdk.api.session.room.send.UserDraft
import org.matrix.android.sdk.api.session.room.timeline.getLastMessageContent
@@ -104,7 +103,7 @@ class TextComposerViewModel @AssistedInject constructor(
}
private fun subscribeToStateInternal() {
- selectSubscribe(TextComposerViewState::sendMode, TextComposerViewState::canSendMessage, TextComposerViewState::isVoiceRecording) { _, _, _ ->
+ onEach(TextComposerViewState::sendMode, TextComposerViewState::canSendMessage, TextComposerViewState::isVoiceRecording) { _, _, _ ->
updateIsSendButtonVisibility(false)
}
}
@@ -123,7 +122,7 @@ class TextComposerViewModel @AssistedInject constructor(
private fun handleEnterEditMode(action: TextComposerAction.EnterEditMode) {
room.getTimeLineEvent(action.eventId)?.let { timelineEvent ->
- setState { copy(sendMode = SendMode.EDIT(timelineEvent, timelineEvent.getTextEditableContent() ?: "")) }
+ setState { copy(sendMode = SendMode.EDIT(timelineEvent, timelineEvent.getTextEditableContent())) }
}
}
@@ -259,11 +258,6 @@ class TextComposerViewModel @AssistedInject constructor(
_viewEvents.post(TextComposerViewEvents.SlashCommandResultOk())
popDraft()
}
- is ParsedCommand.SendPoll -> {
- room.sendPoll(slashCommandResult.question, slashCommandResult.options.mapIndexed { index, s -> OptionItem(s, "$index. $s") })
- _viewEvents.post(TextComposerViewEvents.SlashCommandResultOk())
- popDraft()
- }
is ParsedCommand.ChangeTopic -> {
handleChangeTopicSlashCommand(slashCommandResult)
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/format/DisplayableEventFormatter.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/format/DisplayableEventFormatter.kt
index b5831b33b8..624f22e09b 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/format/DisplayableEventFormatter.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/format/DisplayableEventFormatter.kt
@@ -16,29 +16,33 @@
package im.vector.app.features.home.room.detail.timeline.format
+import dagger.Lazy
import im.vector.app.EmojiCompatWrapper
import im.vector.app.R
import im.vector.app.core.resources.ColorProvider
import im.vector.app.core.resources.StringProvider
+import im.vector.app.features.html.EventHtmlRenderer
import me.gujun.android.span.span
+import org.commonmark.node.Document
import org.matrix.android.sdk.api.session.events.model.EventType
import org.matrix.android.sdk.api.session.events.model.toModel
import org.matrix.android.sdk.api.session.room.model.message.MessageAudioContent
import org.matrix.android.sdk.api.session.room.model.message.MessageOptionsContent
+import org.matrix.android.sdk.api.session.room.model.message.MessageTextContent
import org.matrix.android.sdk.api.session.room.model.message.MessageType
import org.matrix.android.sdk.api.session.room.model.message.OPTION_TYPE_BUTTONS
import org.matrix.android.sdk.api.session.room.model.relation.ReactionContent
import org.matrix.android.sdk.api.session.room.timeline.TimelineEvent
import org.matrix.android.sdk.api.session.room.timeline.getLastMessageContent
-import org.matrix.android.sdk.api.session.room.timeline.getTextEditableContent
-import org.matrix.android.sdk.api.session.room.timeline.isReply
+import org.matrix.android.sdk.api.session.room.timeline.getTextDisplayableContent
import javax.inject.Inject
class DisplayableEventFormatter @Inject constructor(
private val stringProvider: StringProvider,
private val colorProvider: ColorProvider,
private val emojiCompatWrapper: EmojiCompatWrapper,
- private val noticeEventFormatter: NoticeEventFormatter
+ private val noticeEventFormatter: NoticeEventFormatter,
+ private val htmlRenderer: Lazy
) {
fun format(timelineEvent: TimelineEvent, isDm: Boolean, appendAuthor: Boolean): CharSequence {
@@ -53,54 +57,45 @@ class DisplayableEventFormatter @Inject constructor(
val senderName = timelineEvent.senderInfo.disambiguatedDisplayName
- when (timelineEvent.root.getClearType()) {
- EventType.STICKER -> {
- return simpleFormat(senderName, stringProvider.getString(R.string.send_a_sticker), appendAuthor)
- }
- EventType.REACTION -> {
- timelineEvent.root.getClearContent().toModel()?.relatesTo?.let {
- val emojiSpanned = emojiCompatWrapper.safeEmojiSpanify(stringProvider.getString(R.string.sent_a_reaction, it.key))
- return simpleFormat(senderName, emojiSpanned, appendAuthor)
- }
- }
+ return when (timelineEvent.root.getClearType()) {
EventType.MESSAGE -> {
timelineEvent.getLastMessageContent()?.let { messageContent ->
when (messageContent.msgType) {
+ MessageType.MSGTYPE_TEXT -> {
+ val body = messageContent.getTextDisplayableContent()
+ if (messageContent is MessageTextContent && messageContent.matrixFormattedBody.isNullOrBlank().not()) {
+ val localFormattedBody = htmlRenderer.get().parse(body) as Document
+ val renderedBody = htmlRenderer.get().render(localFormattedBody) ?: body
+ simpleFormat(senderName, renderedBody, appendAuthor)
+ } else {
+ simpleFormat(senderName, body, appendAuthor)
+ }
+ }
MessageType.MSGTYPE_VERIFICATION_REQUEST -> {
- return simpleFormat(senderName, stringProvider.getString(R.string.verification_request), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.verification_request), appendAuthor)
}
MessageType.MSGTYPE_IMAGE -> {
- return simpleFormat(senderName, stringProvider.getString(R.string.sent_an_image), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.sent_an_image), appendAuthor)
}
MessageType.MSGTYPE_AUDIO -> {
if ((messageContent as? MessageAudioContent)?.voiceMessageIndicator != null) {
- return simpleFormat(senderName, stringProvider.getString(R.string.sent_a_voice_message), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.sent_a_voice_message), appendAuthor)
} else {
- return simpleFormat(senderName, stringProvider.getString(R.string.sent_an_audio_file), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.sent_an_audio_file), appendAuthor)
}
}
MessageType.MSGTYPE_VIDEO -> {
- return simpleFormat(senderName, stringProvider.getString(R.string.sent_a_video), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.sent_a_video), appendAuthor)
}
MessageType.MSGTYPE_FILE -> {
return simpleFormat(senderName, stringProvider.getString(R.string.sent_a_file), appendAuthor)
}
- MessageType.MSGTYPE_TEXT -> {
- return if (timelineEvent.isReply()) {
- // Skip reply prefix, and show important
- // TODO add a reply image span ?
- simpleFormat(senderName, timelineEvent.getTextEditableContent()
- ?: messageContent.body, appendAuthor)
- } else {
- simpleFormat(senderName, messageContent.body, appendAuthor)
- }
- }
MessageType.MSGTYPE_RESPONSE -> {
// do not show that?
- return span { }
+ span { }
}
MessageType.MSGTYPE_OPTIONS -> {
- return when (messageContent) {
+ when (messageContent) {
is MessageOptionsContent -> {
val previewText = if (messageContent.optionType == OPTION_TYPE_BUTTONS) {
stringProvider.getString(R.string.sent_a_bot_buttons)
@@ -115,15 +110,24 @@ class DisplayableEventFormatter @Inject constructor(
}
}
else -> {
- return simpleFormat(senderName, messageContent.body, appendAuthor)
+ simpleFormat(senderName, messageContent.body, appendAuthor)
}
}
- }
+ } ?: span { }
+ }
+ EventType.STICKER -> {
+ simpleFormat(senderName, stringProvider.getString(R.string.send_a_sticker), appendAuthor)
+ }
+ EventType.REACTION -> {
+ timelineEvent.root.getClearContent().toModel()?.relatesTo?.let {
+ val emojiSpanned = emojiCompatWrapper.safeEmojiSpanify(stringProvider.getString(R.string.sent_a_reaction, it.key))
+ simpleFormat(senderName, emojiSpanned, appendAuthor)
+ } ?: span { }
}
EventType.KEY_VERIFICATION_CANCEL,
EventType.KEY_VERIFICATION_DONE -> {
// cancel and done can appear in timeline, so should have representation
- return simpleFormat(senderName, stringProvider.getString(R.string.sent_verification_conclusion), appendAuthor)
+ simpleFormat(senderName, stringProvider.getString(R.string.sent_verification_conclusion), appendAuthor)
}
EventType.KEY_VERIFICATION_START,
EventType.KEY_VERIFICATION_ACCEPT,
@@ -131,17 +135,15 @@ class DisplayableEventFormatter @Inject constructor(
EventType.KEY_VERIFICATION_KEY,
EventType.KEY_VERIFICATION_READY,
EventType.CALL_CANDIDATES -> {
- return span { }
+ span { }
}
else -> {
- return span {
+ span {
text = noticeEventFormatter.format(timelineEvent, isDm) ?: ""
textStyle = "italic"
}
}
}
-
- return span { }
}
private fun simpleFormat(senderName: String, body: CharSequence, appendAuthor: Boolean): CharSequence {
diff --git a/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/reactions/ViewReactionsViewModel.kt b/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/reactions/ViewReactionsViewModel.kt
index 1f4d67db03..686d767850 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/reactions/ViewReactionsViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/detail/timeline/reactions/ViewReactionsViewModel.kt
@@ -31,18 +31,16 @@ import im.vector.app.core.platform.EmptyAction
import im.vector.app.core.platform.EmptyViewEvents
import im.vector.app.core.platform.VectorViewModel
import im.vector.app.features.home.room.detail.timeline.action.TimelineEventFragmentArgs
-import io.reactivex.Observable
-import io.reactivex.Single
+import kotlinx.coroutines.flow.map
import org.matrix.android.sdk.api.session.Session
-import org.matrix.android.sdk.api.session.room.model.ReactionAggregatedSummary
-import org.matrix.android.sdk.rx.RxRoom
-import org.matrix.android.sdk.rx.unwrap
+import org.matrix.android.sdk.flow.flow
+import org.matrix.android.sdk.flow.unwrap
data class DisplayReactionsViewState(
val eventId: String,
val roomId: String,
val mapReactionKeyToMemberList: Async> = Uninitialized) :
- MavericksState {
+ MavericksState {
constructor(args: TimelineEventFragmentArgs) : this(roomId = args.roomId, eventId = args.eventId)
}
@@ -81,39 +79,31 @@ class ViewReactionsViewModel @AssistedInject constructor(@Assisted
}
private fun observeEventAnnotationSummaries() {
- RxRoom(room)
+ room.flow()
.liveAnnotationSummary(eventId)
.unwrap()
- .flatMapSingle { summaries ->
- Observable
- .fromIterable(summaries.reactionsSummary)
- // .filter { reactionAggregatedSummary -> isSingleEmoji(reactionAggregatedSummary.key) }
- .toReactionInfoList()
+ .map { annotationsSummary ->
+ annotationsSummary.reactionsSummary
+ .flatMap { reactionsSummary ->
+ reactionsSummary.sourceEvents.map {
+ val event = room.getTimeLineEvent(it)
+ ?: throw RuntimeException("Your eventId is not valid")
+ ReactionInfo(
+ event.root.eventId!!,
+ reactionsSummary.key,
+ event.root.senderId ?: "",
+ event.senderInfo.disambiguatedDisplayName,
+ dateFormatter.format(event.root.originServerTs, DateFormatKind.DEFAULT_DATE_AND_TIME)
+
+ )
+ }
+ }
}
.execute {
copy(mapReactionKeyToMemberList = it)
}
}
- private fun Observable.toReactionInfoList(): Single> {
- return flatMap { summary ->
- Observable
- .fromIterable(summary.sourceEvents)
- .map {
- val event = room.getTimeLineEvent(it)
- ?: throw RuntimeException("Your eventId is not valid")
- ReactionInfo(
- event.root.eventId!!,
- summary.key,
- event.root.senderId ?: "",
- event.senderInfo.disambiguatedDisplayName,
- dateFormatter.format(event.root.originServerTs, DateFormatKind.DEFAULT_DATE_AND_TIME)
-
- )
- }
- }.toList()
- }
-
override fun handle(action: EmptyAction) {
// No op
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListDisplayModeFilter.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListDisplayModeFilter.kt
index b8cdac19cf..94a79f5fbd 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListDisplayModeFilter.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListDisplayModeFilter.kt
@@ -16,8 +16,8 @@
package im.vector.app.features.home.room.list
+import androidx.core.util.Predicate
import im.vector.app.features.home.RoomListDisplayMode
-import io.reactivex.functions.Predicate
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.model.RoomSummary
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListFragment.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListFragment.kt
index 1c173e12e8..6543cc8795 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListFragment.kt
@@ -23,6 +23,7 @@ import android.view.View
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.ConcatAdapter
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
@@ -49,6 +50,8 @@ import im.vector.app.features.home.room.list.actions.RoomListQuickActionsSharedA
import im.vector.app.features.home.room.list.actions.RoomListQuickActionsSharedActionViewModel
import im.vector.app.features.home.room.list.widget.NotifsFabMenuView
import im.vector.app.features.notifications.NotificationDrawerManager
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.parcelize.Parcelize
import org.matrix.android.sdk.api.extensions.orTrue
import org.matrix.android.sdk.api.session.room.model.RoomSummary
@@ -118,9 +121,9 @@ class RoomListFragment @Inject constructor(
views.createChatFabMenu.listener = this
sharedActionViewModel
- .observe()
- .subscribe { handleQuickActions(it) }
- .disposeOnDestroyView()
+ .stream()
+ .onEach { handleQuickActions(it) }
+ .launchIn(viewLifecycleOwner.lifecycleScope)
roomListViewModel.onEach(RoomListViewState::roomMembershipChanges) { ms ->
// it's for invites local echo
@@ -479,7 +482,7 @@ class RoomListFragment @Inject constructor(
}
override fun onAcceptRoomInvitation(room: RoomSummary) {
- notificationDrawerManager.clearMemberShipNotificationForRoom(room.roomId)
+ notificationDrawerManager.updateEvents { it.clearMemberShipNotificationForRoom(room.roomId) }
roomListViewModel.handle(RoomListAction.AcceptInvitation(room))
}
@@ -492,7 +495,7 @@ class RoomListFragment @Inject constructor(
}
override fun onRejectRoomInvitation(room: RoomSummary) {
- notificationDrawerManager.clearMemberShipNotificationForRoom(room.roomId)
+ notificationDrawerManager.updateEvents { it.clearMemberShipNotificationForRoom(room.roomId) }
roomListViewModel.handle(RoomListAction.RejectInvitation(room))
}
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListNameFilter.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListNameFilter.kt
index 274cf7c869..edd4c86060 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListNameFilter.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListNameFilter.kt
@@ -16,7 +16,7 @@
package im.vector.app.features.home.room.list
-import io.reactivex.functions.Predicate
+import androidx.core.util.Predicate
import org.matrix.android.sdk.api.session.room.model.RoomSummary
import javax.inject.Inject
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilder.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilder.kt
index 2b3152f8cf..c98f613c40 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilder.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilder.kt
@@ -20,6 +20,4 @@ import im.vector.app.features.home.RoomListDisplayMode
interface RoomListSectionBuilder {
fun buildSections(mode: RoomListDisplayMode): List
-
- fun dispose()
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderGroup.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderGroup.kt
index f101669af3..58db2a4030 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderGroup.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderGroup.kt
@@ -17,6 +17,7 @@
package im.vector.app.features.home.room.list
import androidx.annotation.StringRes
+import androidx.lifecycle.asFlow
import im.vector.app.AppStateHandler
import im.vector.app.R
import im.vector.app.RoomGroupingMethod
@@ -24,17 +25,21 @@ import im.vector.app.core.resources.StringProvider
import im.vector.app.features.home.RoomListDisplayMode
import im.vector.app.features.invite.AutoAcceptInvites
import im.vector.app.features.invite.showInvites
-import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.schedulers.Schedulers
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.query.RoomCategoryFilter
import org.matrix.android.sdk.api.query.RoomTagQueryFilter
import org.matrix.android.sdk.api.session.Session
import org.matrix.android.sdk.api.session.room.RoomSummaryQueryParams
import org.matrix.android.sdk.api.session.room.UpdatableLivePageResult
import org.matrix.android.sdk.api.session.room.model.Membership
-import org.matrix.android.sdk.rx.asObservable
class RoomListSectionBuilderGroup(
+ private val coroutineScope: CoroutineScope,
private val session: Session,
private val stringProvider: StringProvider,
private val appStateHandler: AppStateHandler,
@@ -42,8 +47,6 @@ class RoomListSectionBuilderGroup(
private val onUpdatable: (UpdatableLivePageResult) -> Unit
) : RoomListSectionBuilder {
- private val disposables = CompositeDisposable()
-
override fun buildSections(mode: RoomListDisplayMode): List {
val activeGroupAwareQueries = mutableListOf()
val sections = mutableListOf()
@@ -103,16 +106,14 @@ class RoomListSectionBuilderGroup(
appStateHandler.selectedRoomGroupingObservable
.distinctUntilChanged()
- .subscribe { groupingMethod ->
+ .onEach { groupingMethod ->
val selectedGroupId = (groupingMethod.orNull() as? RoomGroupingMethod.ByLegacyGroup)?.groupSummary?.groupId
activeGroupAwareQueries.onEach { updater ->
updater.updateQuery { query ->
query.copy(activeGroupId = selectedGroupId)
}
}
- }.also {
- disposables.add(it)
- }
+ }.launchIn(coroutineScope)
return sections
}
@@ -251,15 +252,14 @@ class RoomListSectionBuilderGroup(
}.livePagedList
.let { livePagedList ->
// use it also as a source to update count
- livePagedList.asObservable()
- .observeOn(Schedulers.computation())
- .subscribe {
+ livePagedList.asFlow()
+ .onEach {
sections.find { it.sectionName == name }
?.notificationCount
?.postValue(session.getNotificationCountForRooms(roomQueryParams))
- }.also {
- disposables.add(it)
}
+ .flowOn(Dispatchers.Default)
+ .launchIn(coroutineScope)
sections.add(
RoomsSection(
@@ -280,8 +280,4 @@ class RoomListSectionBuilderGroup(
.build()
.let { block(it) }
}
-
- override fun dispose() {
- disposables.dispose()
- }
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderSpace.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderSpace.kt
index 7063281853..bde324e57b 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderSpace.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderSpace.kt
@@ -19,6 +19,7 @@ package im.vector.app.features.home.room.list
import androidx.annotation.StringRes
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.asFlow
import androidx.lifecycle.liveData
import androidx.paging.PagedList
import com.airbnb.mvrx.Async
@@ -29,12 +30,15 @@ import im.vector.app.features.home.RoomListDisplayMode
import im.vector.app.features.invite.AutoAcceptInvites
import im.vector.app.features.invite.showInvites
import im.vector.app.space
-import io.reactivex.Observable
-import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.rxkotlin.Observables
-import io.reactivex.schedulers.Schedulers
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.query.ActiveSpaceFilter
import org.matrix.android.sdk.api.query.RoomCategoryFilter
@@ -44,7 +48,7 @@ import org.matrix.android.sdk.api.session.room.RoomSummaryQueryParams
import org.matrix.android.sdk.api.session.room.UpdatableLivePageResult
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.summary.RoomAggregateNotificationCount
-import org.matrix.android.sdk.rx.asObservable
+import timber.log.Timber
class RoomListSectionBuilderSpace(
private val session: Session,
@@ -57,8 +61,6 @@ class RoomListSectionBuilderSpace(
private val onlyOrphansInHome: Boolean = false
) : RoomListSectionBuilder {
- private val disposables = CompositeDisposable()
-
private val pagedListConfig = PagedList.Config.Builder()
.setPageSize(10)
.setInitialLoadSizeHint(20)
@@ -132,14 +134,12 @@ class RoomListSectionBuilderSpace(
appStateHandler.selectedRoomGroupingObservable
.distinctUntilChanged()
- .subscribe { groupingMethod ->
+ .onEach { groupingMethod ->
val selectedSpace = groupingMethod.orNull()?.space()
activeSpaceAwareQueries.onEach { updater ->
updater.updateForSpaceId(selectedSpace?.roomId)
}
- }.also {
- disposables.add(it)
- }
+ }.launchIn(viewModelScope)
return sections
}
@@ -221,13 +221,13 @@ class RoomListSectionBuilderSpace(
}
// add suggested rooms
- val suggestedRoomsObservable = // MutableLiveData>()
+ val suggestedRoomsFlow = // MutableLiveData>()
appStateHandler.selectedRoomGroupingObservable
.distinctUntilChanged()
- .switchMap { groupingMethod ->
+ .flatMapLatest { groupingMethod ->
val selectedSpace = groupingMethod.orNull()?.space()
if (selectedSpace == null) {
- Observable.just(emptyList())
+ flowOf(emptyList())
} else {
liveData(context = viewModelScope.coroutineContext + Dispatchers.IO) {
val spaceSum = tryOrNull {
@@ -240,24 +240,23 @@ class RoomListSectionBuilderSpace(
session.getRoomSummary(it.childRoomId)?.membership?.isActive() != true
}
emit(filtered)
- }.asObservable()
+ }.asFlow()
}
}
val liveSuggestedRooms = MutableLiveData()
- Observables.combineLatest(
- suggestedRoomsObservable,
- suggestedRoomJoiningState.asObservable()
+ combine(
+ suggestedRoomsFlow,
+ suggestedRoomJoiningState.asFlow()
) { rooms, joinStates ->
SuggestedRoomInfo(
rooms,
joinStates
)
- }.subscribe {
+ }.onEach {
liveSuggestedRooms.postValue(it)
- }.also {
- disposables.add(it)
- }
+ }.launchIn(viewModelScope)
+
sections.add(
RoomsSection(
sectionName = stringProvider.getString(R.string.suggested_header),
@@ -373,9 +372,9 @@ class RoomListSectionBuilderSpace(
}.livePagedList
.let { livePagedList ->
// use it also as a source to update count
- livePagedList.asObservable()
- .observeOn(Schedulers.computation())
- .subscribe {
+ livePagedList.asFlow()
+ .onEach {
+ Timber.v("Thread space list: ${Thread.currentThread()}")
sections.find { it.sectionName == name }
?.notificationCount
?.postValue(
@@ -387,9 +386,9 @@ class RoomListSectionBuilderSpace(
)
}
)
- }.also {
- disposables.add(it)
}
+ .flowOn(Dispatchers.Default)
+ .launchIn(viewModelScope)
sections.add(
RoomsSection(
@@ -432,8 +431,4 @@ class RoomListSectionBuilderSpace(
RoomListViewModel.SpaceFilterStrategy.NONE -> this
}
}
-
- override fun dispose() {
- disposables.dispose()
- }
}
diff --git a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListViewModel.kt b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListViewModel.kt
index b38f2565b6..36f6dcab34 100644
--- a/vector/src/main/java/im/vector/app/features/home/room/list/RoomListViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/home/room/list/RoomListViewModel.kt
@@ -135,6 +135,7 @@ class RoomListViewModel @AssistedInject constructor(
)
} else {
RoomListSectionBuilderGroup(
+ viewModelScope,
session,
stringProvider,
appStateHandler,
@@ -335,9 +336,4 @@ class RoomListViewModel @AssistedInject constructor(
_viewEvents.post(value)
}
}
-
- override fun onCleared() {
- super.onCleared()
- roomListSectionBuilder.dispose()
- }
}
diff --git a/vector/src/main/java/im/vector/app/features/invite/InviteUsersToRoomActivity.kt b/vector/src/main/java/im/vector/app/features/invite/InviteUsersToRoomActivity.kt
index 6f4aff0041..1bf1c12a48 100644
--- a/vector/src/main/java/im/vector/app/features/invite/InviteUsersToRoomActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/invite/InviteUsersToRoomActivity.kt
@@ -21,6 +21,7 @@ import android.content.Intent
import android.os.Bundle
import android.os.Parcelable
import android.view.View
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.Mavericks
import com.airbnb.mvrx.viewModel
import com.google.android.material.dialog.MaterialAlertDialogBuilder
@@ -41,6 +42,8 @@ import im.vector.app.features.userdirectory.UserListFragment
import im.vector.app.features.userdirectory.UserListFragmentArgs
import im.vector.app.features.userdirectory.UserListSharedAction
import im.vector.app.features.userdirectory.UserListSharedActionViewModel
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.parcelize.Parcelize
import org.matrix.android.sdk.api.failure.Failure
import java.net.HttpURLConnection
@@ -63,8 +66,8 @@ class InviteUsersToRoomActivity : SimpleFragmentActivity() {
sharedActionViewModel = viewModelProvider.get(UserListSharedActionViewModel::class.java)
sharedActionViewModel
- .observe()
- .subscribe { sharedAction ->
+ .stream()
+ .onEach { sharedAction ->
when (sharedAction) {
UserListSharedAction.Close -> finish()
UserListSharedAction.GoBack -> onBackPressed()
@@ -75,7 +78,7 @@ class InviteUsersToRoomActivity : SimpleFragmentActivity() {
}
}
}
- .disposeOnDestroy()
+ .launchIn(lifecycleScope)
if (isFirstCreation()) {
addFragment(
R.id.container,
diff --git a/vector/src/main/java/im/vector/app/features/invite/InvitesAcceptor.kt b/vector/src/main/java/im/vector/app/features/invite/InvitesAcceptor.kt
index 09eff756d5..73876bf6e9 100644
--- a/vector/src/main/java/im/vector/app/features/invite/InvitesAcceptor.kt
+++ b/vector/src/main/java/im/vector/app/features/invite/InvitesAcceptor.kt
@@ -18,11 +18,14 @@ package im.vector.app.features.invite
import im.vector.app.ActiveSessionDataSource
import im.vector.app.features.session.coroutineScope
-import io.reactivex.disposables.Disposable
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
@@ -51,7 +54,8 @@ class InvitesAcceptor @Inject constructor(
private val autoAcceptInvites: AutoAcceptInvites
) : Session.Listener {
- private lateinit var activeSessionDisposable: Disposable
+ private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
private val shouldRejectRoomIds = mutableSetOf()
private val activeSessionIds = mutableSetOf()
private val semaphore = Semaphore(1)
@@ -61,13 +65,14 @@ class InvitesAcceptor @Inject constructor(
}
private fun observeActiveSession() {
- activeSessionDisposable = sessionDataSource.observe()
+ sessionDataSource.stream()
.distinctUntilChanged()
- .subscribe {
+ .onEach {
it.orNull()?.let { session ->
onSessionActive(session)
}
}
+ .launchIn(coroutineScope)
}
private fun onSessionActive(session: Session) {
diff --git a/vector/src/main/java/im/vector/app/features/login/LoginActivity.kt b/vector/src/main/java/im/vector/app/features/login/LoginActivity.kt
index 0ca076ccd7..a357caf8fa 100644
--- a/vector/src/main/java/im/vector/app/features/login/LoginActivity.kt
+++ b/vector/src/main/java/im/vector/app/features/login/LoginActivity.kt
@@ -85,10 +85,9 @@ open class LoginActivity : VectorBaseActivity(), ToolbarCo
addFirstFragment()
}
- loginViewModel
- .subscribe(this) {
- updateWithState(it)
- }
+ loginViewModel.onEach {
+ updateWithState(it)
+ }
loginViewModel.observeViewEvents { handleLoginViewEvents(it) }
diff --git a/vector/src/main/java/im/vector/app/features/login/LoginFragment.kt b/vector/src/main/java/im/vector/app/features/login/LoginFragment.kt
index 60f02cb2c6..0978621f28 100644
--- a/vector/src/main/java/im/vector/app/features/login/LoginFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/login/LoginFragment.kt
@@ -25,21 +25,24 @@ import android.view.inputmethod.EditorInfo
import androidx.autofill.HintConstants
import androidx.core.text.isDigitsOnly
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.Fail
import com.airbnb.mvrx.Loading
import com.airbnb.mvrx.Success
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.exhaustive
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.extensions.hidePassword
import im.vector.app.core.extensions.toReducedUrl
import im.vector.app.databinding.FragmentLoginBinding
-import io.reactivex.Observable
-import io.reactivex.rxkotlin.subscribeBy
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.failure.Failure
import org.matrix.android.sdk.api.failure.MatrixError
import org.matrix.android.sdk.api.failure.isInvalidPassword
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
/**
@@ -224,20 +227,18 @@ class LoginFragment @Inject constructor() : AbstractSSOLoginFragment
- isLoginNotEmpty && isPasswordNotEmpty
- }
- )
- .subscribeBy {
+ combine(
+ views.loginField.textChanges().map { it.trim().isNotEmpty() },
+ views.passwordField.textChanges().map { it.isNotEmpty() }
+ ) { isLoginNotEmpty, isPasswordNotEmpty ->
+ isLoginNotEmpty && isPasswordNotEmpty
+ }
+ .onEach {
views.loginFieldTil.error = null
views.passwordFieldTil.error = null
views.loginSubmit.isEnabled = it
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun forgetPasswordClicked() {
diff --git a/vector/src/main/java/im/vector/app/features/login/LoginGenericTextInputFormFragment.kt b/vector/src/main/java/im/vector/app/features/login/LoginGenericTextInputFormFragment.kt
index 925a5c05ab..150cb700cb 100644
--- a/vector/src/main/java/im/vector/app/features/login/LoginGenericTextInputFormFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/login/LoginGenericTextInputFormFragment.kt
@@ -25,19 +25,22 @@ import android.view.View
import android.view.ViewGroup
import androidx.autofill.HintConstants
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.args
import com.google.i18n.phonenumbers.NumberParseException
import com.google.i18n.phonenumbers.PhoneNumberUtil
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.extensions.isEmail
import im.vector.app.core.extensions.setTextOrHide
import im.vector.app.databinding.FragmentLoginGenericTextInputFormBinding
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import kotlinx.parcelize.Parcelize
import org.matrix.android.sdk.api.auth.registration.RegisterThreePid
import org.matrix.android.sdk.api.failure.Failure
import org.matrix.android.sdk.api.failure.is401
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
enum class TextInputFormFragmentMode {
@@ -93,10 +96,10 @@ class LoginGenericTextInputFormFragment @Inject constructor() : AbstractLoginFra
private fun setupTil() {
views.loginGenericTextInputFormTextInput.textChanges()
- .subscribe {
+ .onEach {
views.loginGenericTextInputFormTil.error = null
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun setupUi() {
@@ -195,10 +198,10 @@ class LoginGenericTextInputFormFragment @Inject constructor() : AbstractLoginFra
private fun setupSubmitButton() {
views.loginGenericTextInputFormSubmit.isEnabled = false
views.loginGenericTextInputFormTextInput.textChanges()
- .subscribe {
+ .onEach {
views.loginGenericTextInputFormSubmit.isEnabled = isInputValid(it)
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun isInputValid(input: CharSequence): Boolean {
diff --git a/vector/src/main/java/im/vector/app/features/login/LoginResetPasswordFragment.kt b/vector/src/main/java/im/vector/app/features/login/LoginResetPasswordFragment.kt
index cc113b1eed..a06a569f44 100644
--- a/vector/src/main/java/im/vector/app/features/login/LoginResetPasswordFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/login/LoginResetPasswordFragment.kt
@@ -20,19 +20,22 @@ import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
+import androidx.lifecycle.lifecycleScope
import com.airbnb.mvrx.Fail
import com.airbnb.mvrx.Loading
import com.airbnb.mvrx.Success
import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.R
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.extensions.hidePassword
import im.vector.app.core.extensions.isEmail
import im.vector.app.core.extensions.toReducedUrl
import im.vector.app.databinding.FragmentLoginResetPasswordBinding
-import io.reactivex.Observable
-import io.reactivex.rxkotlin.subscribeBy
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+import reactivecircus.flowbinding.android.widget.textChanges
import javax.inject.Inject
/**
@@ -59,21 +62,18 @@ class LoginResetPasswordFragment @Inject constructor() : AbstractLoginFragment
- isEmail && isPasswordNotEmpty
- }
- )
- .subscribeBy {
+ combine(
+ views.resetPasswordEmail.textChanges().map { it.isEmail() },
+ views.passwordField.textChanges().map { it.isNotEmpty() }
+ ) { isEmail, isPasswordNotEmpty ->
+ isEmail && isPasswordNotEmpty
+ }
+ .onEach {
views.resetPasswordEmailTil.error = null
views.passwordFieldTil.error = null
views.resetPasswordSubmit.isEnabled = it
}
- .disposeOnDestroyView()
+ .launchIn(viewLifecycleOwner.lifecycleScope)
}
private fun submit() {
diff --git a/vector/src/main/java/im/vector/app/features/login/LoginServerUrlFormFragment.kt b/vector/src/main/java/im/vector/app/features/login/LoginServerUrlFormFragment.kt
index ebe82b1163..65ad7af346 100644
--- a/vector/src/main/java/im/vector/app/features/login/LoginServerUrlFormFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/login/LoginServerUrlFormFragment.kt
@@ -25,15 +25,18 @@ import android.view.inputmethod.EditorInfo
import android.widget.ArrayAdapter
import androidx.core.view.isInvisible
import androidx.core.view.isVisible
+import androidx.lifecycle.lifecycleScope
import com.google.android.material.textfield.TextInputLayout
-import com.jakewharton.rxbinding3.widget.textChanges
import im.vector.app.BuildConfig
import im.vector.app.R
import im.vector.app.core.extensions.hideKeyboard
import im.vector.app.core.utils.ensureProtocol
import im.vector.app.core.utils.openUrlInChromeCustomTab
import im.vector.app.databinding.FragmentLoginServerUrlFormBinding
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
import org.matrix.android.sdk.api.failure.Failure
+import reactivecircus.flowbinding.android.widget.textChanges
import java.net.UnknownHostException
import javax.inject.Inject
@@ -61,11 +64,11 @@ class LoginServerUrlFormFragment @Inject constructor() : AbstractLoginFragment
if (actionId == EditorInfo.IME_ACTION_DONE) {
diff --git a/vector/src/main/java/im/vector/app/features/login2/LoginActivity2.kt b/vector/src/main/java/im/vector/app/features/login2/LoginActivity2.kt
index 40dd1d2872..8f1b20aa7f 100644
--- a/vector/src/main/java/im/vector/app/features/login2/LoginActivity2.kt
+++ b/vector/src/main/java/im/vector/app/features/login2/LoginActivity2.kt
@@ -92,10 +92,9 @@ open class LoginActivity2 : VectorBaseActivity