Fixes #1837 - Add support for m.call.invite events in the timeline, room list and notifications

ElementX/Resources/Localizations/en.lproj/Localizable.strings

@@ -105,6 +105,7 @@
 "common_audio" = "Audio";
 "common_blocked_users" = "Blocked users";
 "common_bubbles" = "Bubbles";
+"common_call_invite" = "Call in progress (unsupported)";
 "common_chat_backup" = "Chat backup";
 "common_copyright" = "Copyright";
 "common_creating_room" = "Creating room…";

ElementX/Sources/Generated/Strings.swift

@@ -242,6 +242,8 @@ internal enum L10n {
   internal static var commonBlockedUsers: String { return L10n.tr("Localizable", "common_blocked_users") }
   /// Bubbles
   internal static var commonBubbles: String { return L10n.tr("Localizable", "common_bubbles") }
+  /// Call in progress (unsupported)
+  internal static var commonCallInvite: String { return L10n.tr("Localizable", "common_call_invite") }
   /// Chat backup
   internal static var commonChatBackup: String { return L10n.tr("Localizable", "common_chat_backup") }
   /// Copyright

ElementX/Sources/Screens/RoomScreen/View/Timeline/CallInviteRoomTimelineView.swift

@@ -0,0 +1,48 @@
+//
+// Copyright 2024 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 Compound
+import Foundation
+import SwiftUI
+
+struct CallInviteRoomTimelineView: View {
+    let timelineItem: CallInviteRoomTimelineItem
+    
+    var body: some View {
+        Label(title: { Text(L10n.commonCallInvite) },
+              icon: { CompoundIcon(\.voiceCall, size: .medium, relativeTo: .compound.bodyMD) })
+            .font(.compound.bodyMD)
+            .foregroundColor(.compound.textSecondary)
+            .frame(maxWidth: .infinity, alignment: .center)
+            .padding()
+    }
+}
+
+struct CallInviteRoomTimelineView_Previews: PreviewProvider, TestablePreview {
+    static let viewModel = RoomScreenViewModel.mock
+    
+    static var previews: some View {
+        body.environmentObject(viewModel.context)
+    }
+    
+    static var body: some View {
+        CallInviteRoomTimelineView(timelineItem: .init(id: .random,
+                                                       timestamp: "Now",
+                                                       isEditable: false,
+                                                       canBeRepliedTo: false,
+                                                       sender: .init(id: "Bob")))
+    }
+}

ElementX/Sources/Services/Room/RoomSummary/RoomEventStringBuilder.swift

@@ -68,7 +68,7 @@ struct RoomEventStringBuilder {
         case .poll(let question, _, _, _, _, _, _):
             return prefix(L10n.commonPollSummary(question), with: senderDisplayName)
         case .callInvite:
-            return nil
+            return prefix(L10n.commonCallInvite, with: senderDisplayName)
         }
     }
     

ElementX/Sources/Services/Timeline/TimelineItems/Items/Other/CallInviteRoomTimelineItem.swift

@@ -0,0 +1,28 @@
+//
+// Copyright 2024 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 CallInviteRoomTimelineItem: RoomTimelineItemProtocol, Equatable {
+    let id: TimelineItemIdentifier
+    let timestamp: String
+    let isEditable: Bool
+    let canBeRepliedTo: Bool
+    
+    let sender: TimelineItemSender
+    
+    var properties = RoomTimelineItemProperties()
+}

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

@@ -74,7 +74,7 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
         case .poll(question: let question, kind: let kind, maxSelections: let maxSelections, answers: let answers, votes: let votes, endTime: let endTime, let edited):
             return buildPollTimelineItem(question, kind, maxSelections, answers, votes, endTime, eventItemProxy, isOutgoing, edited)
         case .callInvite:
-            return nil
+            return buildCallInviteTimelineItem(for: eventItemProxy)
         }
     }
     
@@ -422,6 +422,14 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                                                            orderedReadReceipts: orderReadReceipts(eventItemProxy.readReceipts)))
     }
     
+    private func buildCallInviteTimelineItem(for eventItemProxy: EventTimelineItemProxy) -> RoomTimelineItemProtocol {
+        CallInviteRoomTimelineItem(id: eventItemProxy.id,
+                                   timestamp: eventItemProxy.timestamp.formatted(date: .omitted, time: .shortened),
+                                   isEditable: eventItemProxy.isEditable,
+                                   canBeRepliedTo: eventItemProxy.canBeRepliedTo,
+                                   sender: eventItemProxy.sender)
+    }
+    
     private func aggregateReactions(_ reactions: [Reaction]) -> [AggregatedReaction] {
         reactions.map { reaction in
             let senders = reaction.senders

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

@@ -76,6 +76,8 @@ struct RoomTimelineItemView: View {
             PollRoomTimelineView(timelineItem: item)
         case .voice(let item):
             VoiceMessageRoomTimelineView(timelineItem: item, playerState: context.viewState.audioPlayerStateProvider?(item.id) ?? AudioPlayerState(id: .timelineItemIdentifier(item.id), duration: 0))
+        case .callInvite(let item):
+            CallInviteRoomTimelineView(timelineItem: item)
         }
     }
 }

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

@@ -66,6 +66,7 @@ enum RoomTimelineItemType: Equatable {
     case location(LocationRoomTimelineItem)
     case poll(PollRoomTimelineItem)
     case voice(VoiceMessageRoomTimelineItem)
+    case callInvite(CallInviteRoomTimelineItem)
 
     init(item: RoomTimelineItemProtocol) {
         switch item {
@@ -111,6 +112,8 @@ enum RoomTimelineItemType: Equatable {
             self = .poll(item)
         case let item as VoiceMessageRoomTimelineItem:
             self = .voice(item)
+        case let item as CallInviteRoomTimelineItem:
+            self = .callInvite(item)
         default:
             fatalError("Unknown timeline item")
         }
@@ -138,7 +141,8 @@ enum RoomTimelineItemType: Equatable {
              .group(let item as RoomTimelineItemProtocol),
              .location(let item as RoomTimelineItemProtocol),
              .poll(let item as RoomTimelineItemProtocol),
-             .voice(let item as RoomTimelineItemProtocol):
+             .voice(let item as RoomTimelineItemProtocol),
+             .callInvite(let item as RoomTimelineItemProtocol):
             return item.id
         }
     }