Merge branch 'release/0.6.0' into main

.github/workflows/sync-localazy.yml

@@ -36,7 +36,7 @@ jobs:
           ./tools/localazy/importSupportedLocalesFromLocalazy.py
           ./tools/test/generateAllScreenshots.py
       - name: Create Pull Request for Strings
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v7
         with:
           token: ${{ secrets.DANGER_GITHUB_API_TOKEN }}
           commit-message: Sync Strings from Localazy

.github/workflows/sync-sas-strings.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Run SAS String script
         run: ./tools/sas/import_sas_strings.py
       - name: Create Pull Request for SAS Strings
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v7
         with:
           commit-message: Sync SAS Strings
           title: Sync SAS Strings

CHANGES.md

@@ -1,3 +1,35 @@
+Changes in Element X v0.5.3 (2024-09-10)
+========================================
+
+### ✨ Features
+* Add banner for optional migration to simplified sliding sync by @jmartinesp in https://github.com/element-hq/element-x-android/pull/3429
+
+### 🙌 Improvements
+* Timeline : remove the encrypted history banner by @ganfra in https://github.com/element-hq/element-x-android/pull/3410
+
+### 🐛 Bugfixes
+* Fix new logins with Simplified SS using the proxy by @jmartinesp in https://github.com/element-hq/element-x-android/pull/3417
+* Ensure Call is not hang up when user is asked to grant system permissions by @bmarty in https://github.com/element-hq/element-x-android/pull/3419
+* Wait for a room with joined state in `/sync` after creating it by @jmartinesp in https://github.com/element-hq/element-x-android/pull/3421
+* [Bugfix] : fix self verification flow by @ganfra in https://github.com/element-hq/element-x-android/pull/3426
+
+### 🗣 Translations
+* Sync Strings by @ElementBot in https://github.com/element-hq/element-x-android/pull/3425
+
+### 🚧 In development 🚧
+* [Feature] Pinned messages list by @ganfra in https://github.com/element-hq/element-x-android/pull/3392
+* Pinned messages banner : adjust indicator to match design. by @ganfra in https://github.com/element-hq/element-x-android/pull/3415
+
+### Dependency upgrades
+* Update plugin dependencycheck to v10.0.4 by @renovate in https://github.com/element-hq/element-x-android/pull/3372
+* Update plugin detekt to v1.23.7 by @renovate in https://github.com/element-hq/element-x-android/pull/3424
+
+### Others
+* Delete old log files by @bmarty in https://github.com/element-hq/element-x-android/pull/3413
+* Recovery key formatting and wording iteration by @bmarty in https://github.com/element-hq/element-x-android/pull/3409
+* Change license to AGPL by @bmarty in https://github.com/element-hq/element-x-android/pull/3422
+* Remove Wait list screen by @bmarty in https://github.com/element-hq/element-x-android/pull/3428
+
 Changes in Element X v0.5.2 (2024-09-05)
 =========================================
 

fastlane/metadata/android/en-US/changelogs/40006000.txt

@@ -0,0 +1,2 @@
+Element X is the new generation of Element for professional and personal use on mobile. It’s the fastest Matrix client with a seamless & intuitive user interface.
+Full changelog: https://github.com/element-hq/element-x-android/releases

fastlane/metadata/android/en-US/full_description.txt

@@ -1,23 +1,35 @@
-Element X is the future Element. 
-
-It is the brand new, and fastest ever, Matrix client. It is for personal and community use, and will support enterprise functionality later this year.
-
-A complete new build, Element X transforms performance. It’s not just the fastest Matrix client, it’s also fresher and more reliable.
-
-It’s so fast for a number of reasons, but in particular we’ve introduced a completely new syncing service (‘sliding sync’). So even in big end-to-end encrypted chat rooms it operates incredibly quickly.
-
-It’s fresher because we’ve rebuilt the entire user experience. All the power of Matrix - and the complexity of decentralized end-to-end encryption - is now hidden under a beautiful and intuitive user interface using the very latest frameworks and accessibility features.
-
-Element X delivers speed, usability and reliability on the decentralized Matrix open standard.
+Element X brings you both sovereign & seamless collaboration built on Matrix.
+
+The collaboration capabilities include chat & video calls with the modern set of features such as:
+ • public & private channels
+ • room moderation & access conUpdatetrol
+ • replies, reactions, polls, read receipts, pinned messages, etc.
+ • simultaneous chat & calls (picture in picture)
+ • decentralized & federated communication across organizations
+
+All this comes in a secure & sovereign fashion without compromising responsiveness or overall usability of the app:
+ • enterprise-grade single sign-on
+ • easy & secure login & device verification via QR-code
+ • end to end encryption & zero trust
+ • protection against MITM & other cyber attacks
+
+If you’re a new user, use the new Element X app from the start. Compared to the current Element app you will get:
+ • greatly enhanced performance, sleek user interface and overall better user experience
+ • enterprise-grade support for single sign-on (OIDC)
+ • QR-code based login & device verification
+ • natively integrated Element Call for video calls
+ • continuous improvements, bug fixes and new features
+
+If you’re an existing user, using the current Element app - check out the new Element X and start planning your transition. The current Element app will be phased out and will only get critical security updates.
 
 <b>Own your data</b>
 Matrix-based, Element X lets you self-host your data or choose from any free public server (the default is matrix.org, but there are plenty of others to choose from). However you host, you have ownership; it’s your data. You’re not the product. You’re in control.
 
 <b>Interoperate natively</b>
-Enjoy the freedom of the Matrix open standard! You have native interoperability with any other Matrix-based app. So just like email, it doesn't matter if your friends are on a different Matrix-based app you can still connect and chat.
+Enjoy the freedom of the Matrix open standard! You have native interoperability with any other Matrix-based app. So just like email, it doesn't matter if your friends, partners or customers are on a different Matrix-based app - you can still connect.
 
 <b>Encrypt your data</b>
-Enjoy your right to private conversations - free from data mining, ads and all the rest of it - and stay secure. Only the people in your conversation can read your messages. And Element X E2EE applies to voice and video calls too.
+Enjoy your right to private conversations - free from data mining, ads and all the rest of it - and stay secure. Only the people in your conversation can read your messages.
 
 <b>Chat across multiple devices</b>
-Stay in touch wherever you are with fully synchronized message history across all your devices, even those running ‘traditional’ Element, and on the web at https://app.element.io
+Stay in touch wherever you are with fully synchronized message history across all your devices, even those running Element legacy app, and on the web at https://app.element.io

fastlane/metadata/android/en-US/short_description.txt

@@ -1 +1 @@
-Fastest ever Matrix client
+Sovereign. Seamless. On Matrix

fastlane/metadata/android/en-US/title.txt

@@ -1 +1 @@
-Element X - Secure messenger
+Element X - Secure Chat & Call

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/pinned/PinnedEventsTimelineProvider.kt

@@ -18,11 +18,13 @@ import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.TimelineProvider
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import javax.inject.Inject
 
@@ -32,7 +34,8 @@ class PinnedEventsTimelineProvider @Inject constructor(
     private val networkMonitor: NetworkMonitor,
     private val featureFlagService: FeatureFlagService,
 ) : TimelineProvider {
-    private val _timelineStateFlow: MutableStateFlow<AsyncData<Timeline>> = MutableStateFlow(AsyncData.Uninitialized)
+    private val _timelineStateFlow: MutableStateFlow<AsyncData<Timeline>> =
+        MutableStateFlow(AsyncData.Uninitialized)
 
     override fun activeTimelineFlow(): StateFlow<Timeline?> {
         return _timelineStateFlow
@@ -44,25 +47,46 @@ class PinnedEventsTimelineProvider @Inject constructor(
     val timelineStateFlow = _timelineStateFlow
 
     fun launchIn(scope: CoroutineScope) {
+        _timelineStateFlow.subscriptionCount
+            .map { count -> count > 0 }
+            .distinctUntilChanged()
+            .onEach { isActive ->
+                if (isActive) {
+                    onActive()
+                } else {
+                    onInactive()
+                }
+            }
+            .launchIn(scope)
+    }
+
+    private suspend fun onActive() = coroutineScope {
         combine(
             featureFlagService.isFeatureEnabledFlow(FeatureFlags.PinnedEvents),
             networkMonitor.connectivity
-        ) {
-          // do not use connectivity here as data can be loaded from cache, it's just to trigger retry if needed
-          isEnabled, _ ->
+        ) { isEnabled, _ ->
+            // do not use connectivity here as data can be loaded from cache, it's just to trigger retry if needed
             isEnabled
         }
             .onEach { isFeatureEnabled ->
                 if (isFeatureEnabled) {
                     loadTimelineIfNeeded()
                 } else {
-                    _timelineStateFlow.value = AsyncData.Uninitialized
+                    resetTimeline()
                 }
             }
-            .onCompletion {
-                invokeOnTimeline { close() }
-            }
-            .launchIn(scope)
+            .launchIn(this)
+    }
+
+    private suspend fun onInactive() {
+        resetTimeline()
+    }
+
+    private suspend fun resetTimeline() {
+        invokeOnTimeline {
+            close()
+        }
+        _timelineStateFlow.emit(AsyncData.Uninitialized)
     }
 
     suspend fun invokeOnTimeline(action: suspend Timeline.() -> Unit) {

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/pinned/list/PinnedMessagesListPresenter.kt

@@ -15,7 +15,6 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
 import dagger.assisted.Assisted
@@ -27,6 +26,7 @@ import io.element.android.features.messages.impl.actionlist.model.TimelineItemAc
 import io.element.android.features.messages.impl.pinned.PinnedEventsTimelineProvider
 import io.element.android.features.messages.impl.timeline.TimelineRoomInfo
 import io.element.android.features.messages.impl.timeline.factories.TimelineItemsFactory
+import io.element.android.features.messages.impl.timeline.factories.TimelineItemsFactoryConfig
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
@@ -55,16 +55,23 @@ import kotlin.time.Duration.Companion.milliseconds
 class PinnedMessagesListPresenter @AssistedInject constructor(
     @Assisted private val navigator: PinnedMessagesListNavigator,
     private val room: MatrixRoom,
-    private val timelineItemsFactory: TimelineItemsFactory,
+    timelineItemsFactoryCreator: TimelineItemsFactory.Creator,
     private val timelineProvider: PinnedEventsTimelineProvider,
     private val snackbarDispatcher: SnackbarDispatcher,
     actionListPresenterFactory: ActionListPresenter.Factory,
+    private val appCoroutineScope: CoroutineScope,
 ) : Presenter<PinnedMessagesListState> {
     @AssistedFactory
     interface Factory {
         fun create(navigator: PinnedMessagesListNavigator): PinnedMessagesListPresenter
     }
 
+    private val timelineItemsFactory: TimelineItemsFactory = timelineItemsFactoryCreator.create(
+        config = TimelineItemsFactoryConfig(
+            computeReadReceipts = false,
+            computeReactions = false,
+        )
+    )
     private val actionListPresenter = actionListPresenterFactory.create(PinnedMessagesListTimelineActionPostProcessor())
 
     @Composable
@@ -93,10 +100,9 @@ class PinnedMessagesListPresenter @AssistedInject constructor(
             }
         )
 
-        val coroutineScope = rememberCoroutineScope()
         fun handleEvents(event: PinnedMessagesListEvents) {
             when (event) {
-                is PinnedMessagesListEvents.HandleAction -> coroutineScope.handleTimelineAction(event.action, event.event)
+                is PinnedMessagesListEvents.HandleAction -> appCoroutineScope.handleTimelineAction(event.action, event.event)
             }
         }
 

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenter.kt

@@ -22,6 +22,7 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.element.android.features.messages.impl.MessagesNavigator
 import io.element.android.features.messages.impl.timeline.factories.TimelineItemsFactory
+import io.element.android.features.messages.impl.timeline.factories.TimelineItemsFactoryConfig
 import io.element.android.features.messages.impl.timeline.model.NewEventState
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.voicemessages.timeline.RedactedVoiceMessageManager
@@ -54,7 +55,7 @@ import kotlinx.coroutines.withContext
 const val FOCUS_ON_PINNED_EVENT_DEBOUNCE_DURATION_IN_MILLIS = 200L
 
 class TimelinePresenter @AssistedInject constructor(
-    private val timelineItemsFactory: TimelineItemsFactory,
+    timelineItemsFactoryCreator: TimelineItemsFactory.Creator,
     private val timelineItemIndexer: TimelineItemIndexer,
     private val room: MatrixRoom,
     private val dispatchers: CoroutineDispatchers,
@@ -71,6 +72,13 @@ class TimelinePresenter @AssistedInject constructor(
         fun create(navigator: MessagesNavigator): TimelinePresenter
     }
 
+    private val timelineItemsFactory: TimelineItemsFactory = timelineItemsFactoryCreator.create(
+        config = TimelineItemsFactoryConfig(
+            computeReadReceipts = true,
+            computeReactions = true,
+        )
+    )
+
     @Composable
     override fun present(): TimelineState {
         val localScope = rememberCoroutineScope()

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt

@@ -7,6 +7,9 @@
 
 package io.element.android.features.messages.impl.timeline.factories
 
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
 import io.element.android.features.messages.impl.timeline.TimelineItemIndexer
 import io.element.android.features.messages.impl.timeline.diff.TimelineItemsCacheInvalidator
 import io.element.android.features.messages.impl.timeline.factories.event.TimelineItemEventFactory
@@ -26,15 +29,21 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import javax.inject.Inject
 
-class TimelineItemsFactory @Inject constructor(
+class TimelineItemsFactory @AssistedInject constructor(
+    @Assisted config: TimelineItemsFactoryConfig,
+    eventItemFactoryCreator: TimelineItemEventFactory.Creator,
     private val dispatchers: CoroutineDispatchers,
-    private val eventItemFactory: TimelineItemEventFactory,
     private val virtualItemFactory: TimelineItemVirtualFactory,
     private val timelineItemGrouper: TimelineItemGrouper,
     private val timelineItemIndexer: TimelineItemIndexer,
 ) {
+    @AssistedFactory
+    interface Creator {
+        fun create(config: TimelineItemsFactoryConfig): TimelineItemsFactory
+    }
+
+    private val eventItemFactory = eventItemFactoryCreator.create(config)
     private val _timelineItems = MutableSharedFlow<ImmutableList<TimelineItem>>(replay = 1)
     private val lock = Mutex()
     private val diffCache = MutableListDiffCache<TimelineItem>()

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactoryConfig.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.messages.impl.timeline.factories
+
+/**
+ * Some data used to configure the creation of timeline items.
+ * @param computeReadReceipts when false, read receipts will be empty.
+ * @param computeReactions when false, reactions will be empty.
+ */
+data class TimelineItemsFactoryConfig(
+    val computeReadReceipts: Boolean,
+    val computeReactions: Boolean,
+)