Add encryption history banner and update session verification banner strings. (#1250)

* Add a hard wall on back-pagination in encrypted rooms.
Until the app supports key backup, the history will never be decryptable.

* Fix initial display of the timeline table view.

* Update session verification banner strings.

ElementX/Sources/Services/Timeline/TimelineController/MockRoomTimelineControllerFactory.swift

@@ -17,8 +17,7 @@
 import Foundation
 
 struct MockRoomTimelineControllerFactory: RoomTimelineControllerFactoryProtocol {
-    func buildRoomTimelineController(userId: String,
-                                     roomProxy: RoomProxyProtocol,
+    func buildRoomTimelineController(roomProxy: RoomProxyProtocol,
                                      timelineItemFactory: RoomTimelineItemFactoryProtocol,
                                      mediaProvider: MediaProviderProtocol) -> RoomTimelineControllerProtocol {
         let timelineController = MockRoomTimelineController()

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineController.swift

@@ -19,7 +19,6 @@ import Foundation
 import UIKit
 
 class RoomTimelineController: RoomTimelineControllerProtocol {
-    private let userId: String
     private let roomProxy: RoomProxyProtocol
     private let timelineProvider: RoomTimelineProviderProtocol
     private let timelineItemFactory: RoomTimelineItemFactoryProtocol
@@ -42,12 +41,10 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         roomProxy.id
     }
     
-    init(userId: String,
-         roomProxy: RoomProxyProtocol,
+    init(roomProxy: RoomProxyProtocol,
          timelineItemFactory: RoomTimelineItemFactoryProtocol,
          mediaProvider: MediaProviderProtocol,
          appSettings: AppSettings) {
-        self.userId = userId
         self.roomProxy = roomProxy
         timelineProvider = roomProxy.timelineProvider
         self.timelineItemFactory = timelineItemFactory
@@ -246,6 +243,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         var newTimelineItems = [RoomTimelineItemProtocol]()
         var canBackPaginate = true
         var isBackPaginating = false
+        var lastEncryptedHistoryItemIndex: Int?
         
         let collapsibleChunks = timelineProvider.itemsPublisher.value.groupBy { isItemCollapsible($0) }
         
@@ -264,6 +262,8 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
                     isBackPaginating = true
                 } else if timelineItem is TimelineStartRoomTimelineItem {
                     canBackPaginate = false
+                } else if timelineItem is EncryptedHistoryRoomTimelineItem {
+                    canBackPaginate = false
                 }
                 
                 return timelineItem
@@ -280,11 +280,21 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
                     continue
                 }
                 
+                if timelineItem is EncryptedHistoryRoomTimelineItem {
+                    lastEncryptedHistoryItemIndex = newTimelineItems.endIndex
+                }
+                
                 newTimelineItems.append(timelineItem)
             } else {
                 newTimelineItems.append(CollapsibleTimelineItem(items: items))
             }
         }
+        
+        if let lastEncryptedHistoryItemIndex {
+            // Remove everything up to the last encrypted history item.
+            // It only contains encrypted messages, state changes and date separators.
+            newTimelineItems.removeFirst(lastEncryptedHistoryItemIndex)
+        }
 
         timelineItems = newTimelineItems
         
@@ -298,6 +308,10 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         case .event(let eventTimelineItem):
             let timelineItem = timelineItemFactory.buildTimelineItem(for: eventTimelineItem)
             
+            if timelineItem is EncryptedRoomTimelineItem, isItemInEncryptionHistory(eventTimelineItem) {
+                return EncryptedHistoryRoomTimelineItem(id: eventTimelineItem.id)
+            }
+            
             if let messageTimelineItem = timelineItem as? EventBasedMessageTimelineItemProtocol {
                 // Avoid fetching this over and over again as it changes states if it keeps failing to load
                 // Errors will be handled again on appearance
@@ -326,6 +340,13 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         }
     }
     
+    /// Whether or not a specific item is part of the room's history that can't be decrypted due
+    /// to the lack of key-backup. This is handled differently so we only show a single item.
+    private func isItemInEncryptionHistory(_ itemProxy: EventTimelineItemProxy) -> Bool {
+        guard roomProxy.isEncrypted, let lastLoginDate = appSettings.lastLoginDate else { return false }
+        return itemProxy.timestamp < lastLoginDate
+    }
+    
     private func isItemCollapsible(_ item: TimelineItemProxy) -> Bool {
         if !appSettings.shouldCollapseRoomStateEvents {
             return false

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineControllerFactory.swift

@@ -17,12 +17,10 @@
 import Foundation
 
 struct RoomTimelineControllerFactory: RoomTimelineControllerFactoryProtocol {
-    func buildRoomTimelineController(userId: String,
-                                     roomProxy: RoomProxyProtocol,
+    func buildRoomTimelineController(roomProxy: RoomProxyProtocol,
                                      timelineItemFactory: RoomTimelineItemFactoryProtocol,
                                      mediaProvider: MediaProviderProtocol) -> RoomTimelineControllerProtocol {
-        RoomTimelineController(userId: userId,
-                               roomProxy: roomProxy,
+        RoomTimelineController(roomProxy: roomProxy,
                                timelineItemFactory: timelineItemFactory,
                                mediaProvider: mediaProvider,
                                appSettings: ServiceLocator.shared.settings)

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineControllerFactoryProtocol.swift

@@ -18,8 +18,7 @@ import Foundation
 
 @MainActor
 protocol RoomTimelineControllerFactoryProtocol {
-    func buildRoomTimelineController(userId: String,
-                                     roomProxy: RoomProxyProtocol,
+    func buildRoomTimelineController(roomProxy: RoomProxyProtocol,
                                      timelineItemFactory: RoomTimelineItemFactoryProtocol,
                                      mediaProvider: MediaProviderProtocol) -> RoomTimelineControllerProtocol
 }

ElementX/Sources/Services/Timeline/TimelineItems/Items/Virtual/EncryptedHistoryRoomTimelineItem.swift

@@ -0,0 +1,21 @@
+//
+// Copyright 2023 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.
+//
+
+import Foundation
+
+struct EncryptedHistoryRoomTimelineItem: DecorationTimelineItemProtocol, Identifiable, Hashable {
+    let id: String
+}

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemView.swift

@@ -55,6 +55,8 @@ struct RoomTimelineItemView: View {
             UnsupportedRoomTimelineView(timelineItem: item)
         case .timelineStart(let item):
             TimelineStartRoomTimelineView(timelineItem: item)
+        case .encryptedHistory(let item):
+            EncryptedHistoryRoomTimelineView(timelineItem: item)
         case .state(let item):
             StateRoomTimelineView(timelineItem: item)
         case .group(let item):

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemViewModel.swift

@@ -58,6 +58,7 @@ enum RoomTimelineItemType: Equatable {
     case sticker(StickerRoomTimelineItem)
     case unsupported(UnsupportedRoomTimelineItem)
     case timelineStart(TimelineStartRoomTimelineItem)
+    case encryptedHistory(EncryptedHistoryRoomTimelineItem)
     case state(StateRoomTimelineItem)
     case group(CollapsibleTimelineItem)
     case location(LocationRoomTimelineItem)
@@ -95,6 +96,8 @@ enum RoomTimelineItemType: Equatable {
             self = .unsupported(item)
         case let item as TimelineStartRoomTimelineItem:
             self = .timelineStart(item)
+        case let item as EncryptedHistoryRoomTimelineItem:
+            self = .encryptedHistory(item)
         case let item as StateRoomTimelineItem:
             self = .state(item)
         case let item as CollapsibleTimelineItem:
@@ -123,6 +126,7 @@ enum RoomTimelineItemType: Equatable {
              .sticker(let item as RoomTimelineItemProtocol),
              .unsupported(let item as RoomTimelineItemProtocol),
              .timelineStart(let item as RoomTimelineItemProtocol),
+             .encryptedHistory(let item as RoomTimelineItemProtocol),
              .state(let item as RoomTimelineItemProtocol),
              .group(let item as RoomTimelineItemProtocol),
              .location(let item as RoomTimelineItemProtocol):
@@ -137,7 +141,7 @@ enum RoomTimelineItemType: Equatable {
             return true
         case .redacted, .encrypted, .unsupported, .state: // Event based items that aren't reactable
             return false
-        case .timelineStart, .separator, .readMarker, .paginationIndicator: // Virtual items are never reactable
+        case .timelineStart, .encryptedHistory, .separator, .readMarker, .paginationIndicator: // Virtual items are never reactable
             return false
         case .group:
             return false