Merge remote-tracking branch 'upstream/dev' into feature/groups-rebuild

# Conflicts:
#	Session.xcodeproj/project.pbxproj
#	Session/Calls/Call Management/SessionCallManager+Action.swift
#	Session/Calls/Call Management/SessionCallManager+CXProvider.swift
#	Session/Calls/Call Management/SessionCallManager.swift
#	Session/Calls/WebRTC/WebRTCSession.swift
#	Session/Conversations/ConversationVC+Interaction.swift
#	Session/Conversations/Settings/ThreadSettingsViewModel.swift
#	Session/Media Viewing & Editing/GIFs/GifPickerViewController.swift
#	Session/Media Viewing & Editing/PhotoCapture.swift
#	Session/Media Viewing & Editing/PhotoLibrary.swift
#	Session/Notifications/NotificationPresenter.swift
#	Session/Notifications/PushRegistrationManager.swift
#	Session/Settings/HelpViewModel.swift
#	SessionMessagingKit/Database/Models/LinkPreview.swift
#	SessionMessagingKit/Sending & Receiving/Attachments/SignalAttachment.swift
#	SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+LegacyClosedGroups.swift
#	SessionMessagingKit/Sending & Receiving/Message Handling/MessageSender+LegacyClosedGroups.swift
#	SessionNotificationServiceExtension/NotificationServiceExtension.swift
#	SessionShareExtension/ShareNavController.swift
#	SessionShareExtension/ThreadPickerVC.swift
#	SessionUtilitiesKit/Media/DataSource.swift

Session/Calls/Call Management/SessionCall.swift

@@ -186,7 +186,7 @@ public final class SessionCall: CurrentCallProtocol, WebRTCSessionDelegate {
     // stringlint:ignore_contents
     func reportIncomingCallIfNeeded(completion: @escaping (Error?) -> Void) {
         guard case .answer = mode else {
-            SessionCallManager.reportFakeCall(info: "Call not in answer mode", using: dependencies)
+            Singleton.callManager.reportFakeCall(info: "Call not in answer mode")
             return
         }
         
@@ -269,12 +269,13 @@ public final class SessionCall: CurrentCallProtocol, WebRTCSessionDelegate {
         hasStartedConnecting = true
         
         if let sdp = remoteSDP {
+            SNLog("[Calls] Got remote sdp already")
             webRTCSession.handleRemoteSDP(sdp, from: sessionId) // This sends an answer message internally
         }
     }
     
-    func answerSessionCallInBackground(action: CXAnswerCallAction) {
-        answerCallAction = action
+    func answerSessionCallInBackground() {
+        SNLog("[Calls] Answering call in background")
         self.answerSessionCall()
     }
     

Session/Calls/Call Management/SessionCallManager+Action.swift

@@ -17,20 +17,16 @@ extension SessionCallManager {
         return true
     }
     
-    @discardableResult
-    public func answerCallAction() -> Bool {
-        guard
-            let call: SessionCall = (self.currentCall as? SessionCall),
-            dependencies[singleton: .appContext].isValid
-        else { return false }
+    public func answerCallAction() {
+        guard let call: SessionCall = (self.currentCall as? SessionCall) else { return }
         
         if dependencies[singleton: .appContext].frontMostViewController is CallVC {
             call.answerSessionCall()
         }
         else {
-            guard let presentingVC = dependencies[singleton: .appContext].frontMostViewController else { return false } // FIXME: Handle more gracefully
+            guard let presentingVC = dependencies[singleton: .appContext].frontMostViewController else { return } // FIXME: Handle more gracefully
             let callVC = CallVC(for: call, using: dependencies)
-            
+
             if let conversationVC = presentingVC as? ConversationVC {
                 callVC.conversationVC = conversationVC
                 conversationVC.inputAccessoryView?.isHidden = true
@@ -41,8 +37,6 @@ extension SessionCallManager {
                 call.answerSessionCall()
             }
         }
-        
-        return true
     }
     
     @discardableResult

Session/Calls/Call Management/SessionCallManager+CXProvider.swift

@@ -25,18 +25,18 @@ extension SessionCallManager: CXProviderDelegate {
         Log.assertOnMainThread()
         Log.debug(.calls, "Perform CXAnswerCallAction")
         
-        guard let call: SessionCall = (self.currentCall as? SessionCall) else { return action.fail() }
+        guard let call: SessionCall = (self.currentCall as? SessionCall) else {
+            Log.warn("[CallKit] No session call")
+            return action.fail()
+        }
+        
+        call.answerCallAction = action
         
         if dependencies[singleton: .appContext].isMainAppAndActive {
-            if answerCallAction() {
-                action.fulfill()
-            }
-            else {
-                action.fail()
-            }
+            self.answerCallAction()
         }
         else {
-            call.answerSessionCallInBackground(action: action)
+            call.answerSessionCallInBackground()
         }
     }
     

Session/Calls/Call Management/SessionCallManager.swift

@@ -8,16 +8,22 @@ import SessionUIKit
 import SessionMessagingKit
 import SignalUtilitiesKit
 import SessionUtilitiesKit
- 
-// MARK: - Cache
 
-public extension Cache {
-    static let callManager: CacheConfig<CallManagerCacheType, CallManagerImmutableCacheType> = Dependencies.create(
-        identifier: "callManager",
-        createInstance: { _ in SessionCallManager.Cache() },
-        mutableInstance: { $0 },
-        immutableInstance: { $0 }
-    )
+// MARK: - CXProviderConfiguration
+
+public extension CXProviderConfiguration {
+    static func defaultConfiguration(_ useSystemCallLog: Bool = false) -> CXProviderConfiguration {
+        let iconMaskImage: UIImage = #imageLiteral(resourceName: "SessionGreen32")
+        let configuration = CXProviderConfiguration()
+        configuration.supportsVideo = true
+        configuration.maximumCallGroups = 1
+        configuration.maximumCallsPerCallGroup = 1
+        configuration.supportedHandleTypes = [.generic]
+        configuration.iconTemplateImageData = iconMaskImage.pngData()
+        configuration.includesCallsInRecents = useSystemCallLog
+        
+        return configuration
+    }
 }
 
 // MARK: - SessionCallManager
@@ -48,9 +54,7 @@ public final class SessionCallManager: NSObject, CallManagerProtocol {
         self.dependencies = dependencies
         
         if Preferences.isCallKitSupported {
-            self.provider = dependencies.mutate(cache: .callManager) {
-                $0.getOrCreateProvider(useSystemCallLog: useSystemCallLog)
-            }
+            self.provider = CXProvider(configuration: .defaultConfiguration(useSystemCallLog))
             self.callController = CXCallController()
         }
         else {
@@ -66,18 +70,15 @@ public final class SessionCallManager: NSObject, CallManagerProtocol {
     
     // MARK: - Report calls
     
-    public static func reportFakeCall(info: String, using dependencies: Dependencies) {
+    public func reportFakeCall(info: String) {
         let callId = UUID()
-        let provider: CXProvider = dependencies.mutate(cache: .callManager) {
-            $0.getOrCreateProvider(useSystemCallLog: false)
-        }
-        provider.reportNewIncomingCall(
+        self.provider?.reportNewIncomingCall(
             with: callId,
             update: CXCallUpdate()
         ) { _ in
             Log.error(.calls, "Reported fake incoming call to CallKit due to: \(info)")
         }
-        provider.reportCall(
+        self.provider?.reportCall(
             with: callId,
             endedAt: nil,
             reason: .failed
@@ -104,14 +105,7 @@ public final class SessionCallManager: NSObject, CallManagerProtocol {
         }
     }
     
-    public func reportIncomingCall(
-        _ call: CurrentCallProtocol,
-        callerName: String,
-        completion: @escaping (Error?) -> Void
-    ) {
-        let provider: CXProvider = dependencies.mutate(cache: .callManager) {
-            $0.getOrCreateProvider(useSystemCallLog: false)
-        }
+    public func reportIncomingCall(_ call: CurrentCallProtocol, callerName: String, completion: @escaping (Error?) -> Void) {
         // Construct a CXCallUpdate describing the incoming call, including the caller.
         let update = CXCallUpdate()
         update.localizedCallerName = callerName
@@ -121,7 +115,7 @@ public final class SessionCallManager: NSObject, CallManagerProtocol {
         disableUnsupportedFeatures(callUpdate: update)
 
         // Report the incoming call to the system
-        provider.reportNewIncomingCall(with: call.callId, update: update) { [dependencies] error in
+        self.provider?.reportNewIncomingCall(with: call.callId, update: update) { [dependencies] error in
             guard error == nil else {
                 self.reportCurrentCallEnded(reason: .failed)
                 completion(error)
@@ -296,39 +290,3 @@ public final class SessionCallManager: NSObject, CallManagerProtocol {
         MiniCallView.current?.dismiss()
     }
 }
-
-// MARK: - SessionCallManager Cache
-
-public extension SessionCallManager {
-    class Cache: CallManagerCacheType {
-        public var provider: CXProvider?
-        
-        public func getOrCreateProvider(useSystemCallLog: Bool) -> CXProvider {
-            if let provider: CXProvider = self.provider {
-                return provider
-            }
-            
-            let iconMaskImage: UIImage = #imageLiteral(resourceName: "SessionGreen32")
-            let configuration = CXProviderConfiguration()
-            configuration.supportsVideo = true
-            configuration.maximumCallGroups = 1
-            configuration.maximumCallsPerCallGroup = 1
-            configuration.supportedHandleTypes = [.generic]
-            configuration.iconTemplateImageData = iconMaskImage.pngData()
-            configuration.includesCallsInRecents = useSystemCallLog
-            
-            let provider: CXProvider = CXProvider(configuration: configuration)
-            self.provider = provider
-            return provider
-        }
-    }
-}
-
-// MARK: - OGMCacheType
-
-/// This is a read-only version of the Cache designed to avoid unintentionally mutating the instance in a non-thread-safe way
-public protocol CallManagerImmutableCacheType: ImmutableCacheType {}
-
-public protocol CallManagerCacheType: CallManagerImmutableCacheType, MutableCacheType {
-    func getOrCreateProvider(useSystemCallLog: Bool) -> CXProvider
-}

Session/Calls/CallVC.swift

@@ -603,6 +603,7 @@ final class CallVC: UIViewController, VideoPreviewDelegate {
         Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { [weak self] _ in
             DispatchQueue.main.async {
                 self?.dismiss(animated: true, completion: {
+                    self?.conversationVC?.becomeFirstResponder()
                     self?.conversationVC?.showInputAccessoryView()
                 })
             }
@@ -648,6 +649,7 @@ final class CallVC: UIViewController, VideoPreviewDelegate {
     
     @objc private func minimize() {
         self.shouldRestartCamera = false
+        self.conversationVC?.becomeFirstResponder()
         self.conversationVC?.showInputAccessoryView()
         
         let miniCallView = MiniCallView(from: self, using: dependencies)

Session/Calls/WebRTC/WebRTCSession.swift

@@ -104,6 +104,7 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
         self.dependencies = dependencies
         self.contactSessionId = contactSessionId
         self.uuid = uuid
+        self.dependencies = dependencies
         
         super.init()
         
@@ -157,6 +158,7 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
         Log.info(.calls, "Sending offer message.")
         let uuid: String = self.uuid
         let mediaConstraints: RTCMediaConstraints = mediaConstraints(isRestartingICEConnection)
+        let dependencies: Dependencies = self.dependencies
         
         return Deferred { [weak self, dependencies] in
             Future<Void, Error> { resolver in
@@ -220,6 +222,7 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
         Log.info(.calls, "Sending answer message.")
         let uuid: String = self.uuid
         let mediaConstraints: RTCMediaConstraints = mediaConstraints(false)
+        let dependencies: Dependencies = self.dependencies
         
         return dependencies[singleton: .storage]
             .readPublisher { db -> SessionThread in
@@ -302,6 +305,7 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
         let candidates: [RTCIceCandidate] = self.queuedICECandidates
         let uuid: String = self.uuid
         let contactSessionId: String = self.contactSessionId
+        let dependencies: Dependencies = self.dependencies
         
         // Empty the queue
         self.queuedICECandidates.removeAll()
@@ -344,7 +348,10 @@ public final class WebRTCSession : NSObject, RTCPeerConnectionDelegate {
             .sinkUntilComplete()
     }
     
-    public func endCall(_ db: Database, with sessionId: String) throws {
+    public func endCall(
+        _ db: Database,
+        with sessionId: String
+    ) throws {
         guard let thread: SessionThread = try SessionThread.fetchOne(db, id: sessionId) else { return }
         
         Log.info(.calls, "Sending end call message.")

Session/Conversations/ConversationVC+Interaction.swift

@@ -416,7 +416,7 @@ extension ConversationVC:
         }
         
         let fileName: String = (urlResourceValues.name ?? "attachment".localized())
-        guard let dataSource = DataSourcePath(fileUrl: url, shouldDeleteOnDeinit: false, using: viewModel.dependencies) else {
+        guard let dataSource = DataSourcePath(fileUrl: url, sourceFilename: urlResourceValues.name, shouldDeleteOnDeinit: false, using: viewModel.dependencies) else {
             DispatchQueue.main.async { [weak self] in
                 self?.viewModel.showToast(text: "attachmentsErrorLoad".localized())
             }
@@ -451,7 +451,7 @@ extension ConversationVC:
     func showAttachmentApprovalDialogAfterProcessingVideo(at url: URL, with fileName: String) {
         ModalActivityIndicatorViewController.present(fromViewController: self, canCancel: true, message: nil) { [weak self, dependencies = viewModel.dependencies] modalActivityIndicator in
             
-            guard let dataSource = DataSourcePath(fileUrl: url, shouldDeleteOnDeinit: false, using: dependencies) else {
+            guard let dataSource = DataSourcePath(fileUrl: url, sourceFilename: fileName, shouldDeleteOnDeinit: false, using: dependencies) else {
                 self?.showErrorAlert(for: SignalAttachment.empty(using: dependencies))
                 return
             }
@@ -2410,7 +2410,7 @@ extension ConversationVC:
         }
         
         // Get data
-        let dataSourceOrNil = DataSourcePath(fileUrl: audioRecorder.url, shouldDeleteOnDeinit: true, using: viewModel.dependencies)
+        let dataSourceOrNil = DataSourcePath(fileUrl: audioRecorder.url, sourceFilename: nil, shouldDeleteOnDeinit: true, using: viewModel.dependencies)
         self.audioRecorder = nil
         
         guard let dataSource = dataSourceOrNil else { return SNLog("Couldn't load recorded data.") }

Session/Conversations/Settings/ThreadSettingsViewModel.swift

@@ -859,14 +859,13 @@ class ThreadSettingsViewModel: SessionTableViewModel, NavigatableStateHolder, Ob
                         dependencies[singleton: .storage]
                             .writePublisher { db in
                                 try selectedUserInfo.forEach { userInfo in
+                                    let sentTimestampMs: Int64 = dependencies[cache: .snodeAPI].currentOffsetTimestampMs()
                                     let thread: SessionThread = try SessionThread.upsert(
                                         db,
                                         id: userInfo.profileId,
                                         variant: .contact,
                                         values: SessionThread.TargetValues(
-                                            creationDateTimestamp: .useExistingOrSetTo(
-                                                dependencies[cache: .snodeAPI].currentOffsetTimestampMs() / 1000
-                                            ),
+                                            creationDateTimestamp: .useExistingOrSetTo(TimeInterval(sentTimestampMs) / 1000),
                                             shouldBeVisible: .useExisting
                                         ),
                                         calledFromConfig: nil,
@@ -881,18 +880,18 @@ class ThreadSettingsViewModel: SessionTableViewModel, NavigatableStateHolder, Ob
                                     )
                                     .upsert(db)
                                     
+                                    let destinationDisappearingMessagesConfiguration: DisappearingMessagesConfiguration? = try? DisappearingMessagesConfiguration
+                                        .filter(id: userId)
+                                        .filter(DisappearingMessagesConfiguration.Columns.isEnabled == true)
+                                        .fetchOne(db)
                                     let interaction: Interaction = try Interaction(
                                         threadId: thread.id,
                                         threadVariant: thread.variant,
-                                        authorId: userInfo.profileId,
+                                        authorId: threadViewModel.currentUserSessionId,
                                         variant: .standardOutgoing,
-                                        timestampMs: dependencies[cache: .snodeAPI].currentOffsetTimestampMs(),
-                                        expiresInSeconds: try? DisappearingMessagesConfiguration
-                                            .select(.durationSeconds)
-                                            .filter(id: userInfo.profileId)
-                                            .filter(DisappearingMessagesConfiguration.Columns.isEnabled == true)
-                                            .asRequest(of: TimeInterval.self)
-                                            .fetchOne(db),
+                                        timestampMs: sentTimestampMs,
+                                        expiresInSeconds: destinationDisappearingMessagesConfiguration?.durationSeconds,
+                                        expiresStartedAtMs: (destinationDisappearingMessagesConfiguration?.type == .disappearAfterSend ? Double(sentTimestampMs) : nil),
                                         linkPreviewUrl: communityUrl,
                                         using: dependencies
                                     )
@@ -912,7 +911,7 @@ class ThreadSettingsViewModel: SessionTableViewModel, NavigatableStateHolder, Ob
                                         job: DisappearingMessagesJob.updateNextRunIfNeeded(
                                             db,
                                             interaction: interaction,
-                                            startedAtMs: dependencies[cache: .snodeAPI].currentOffsetTimestampMs(),
+                                            startedAtMs: sentTimestampMs,
                                             using: dependencies
                                         ),
                                         canStartJob: true

Session/Media Viewing & Editing/GIFs/GifPickerViewController.swift

@@ -383,7 +383,7 @@ class GifPickerViewController: OWSViewController, UISearchBarDelegate, UICollect
                         return
                     }
 
-                    let dataSource = DataSourcePath(filePath: asset.filePath, shouldDeleteOnDeinit: false, using: dependencies)
+                    let dataSource = DataSourcePath(filePath: asset.filePath, sourceFilename: URL(fileURLWithPath: asset.filePath).pathExtension, shouldDeleteOnDeinit: false, using: dependencies)
                     let attachment = SignalAttachment.attachment(dataSource: dataSource, type: rendition.type, imageQuality: .medium, using: dependencies)
 
                     self?.dismiss(animated: true) {

Session/Media Viewing & Editing/PhotoCapture.swift

@@ -446,7 +446,7 @@ extension PhotoCapture: CaptureOutputDelegate {
             Log.debug("[PhotoCapture] Ignoring error, since capture succeeded.")
         }
 
-        let dataSource = DataSourcePath(fileUrl: outputFileURL, shouldDeleteOnDeinit: true, using: dependencies)
+        let dataSource = DataSourcePath(fileUrl: outputFileURL, sourceFilename: nil, shouldDeleteOnDeinit: true, using: dependencies)
         let attachment = SignalAttachment.attachment(dataSource: dataSource, type: .mpeg4Movie, using: dependencies)
         delegate?.photoCapture(self, didFinishProcessingAttachment: attachment)
     }

Session/Media Viewing & Editing/PhotoLibrary.swift

@@ -195,7 +195,7 @@ class PhotoCollectionContents {
                         
                         guard
                             exportSession?.status == .completed,
-                            let dataSource = DataSourcePath(fileUrl: exportURL, shouldDeleteOnDeinit: true, using: dependencies)
+                            let dataSource = DataSourcePath(fileUrl: exportURL, sourceFilename: nil, shouldDeleteOnDeinit: true, using: dependencies)
                         else {
                             resolver(Result.failure(PhotoLibraryError.assertionError(description: "Failed to build data source for exported video URL")))
                             return

Session/Meta/Translations/Localizable.xcstrings

@@ -12563,6 +12563,17 @@
         }
       }
     },
+    "adminPromotionNotSent" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Promotion not sent"
+          }
+        }
+      }
+    },
     "adminPromotionSent" : {
       "extractionState" : "manual",
       "localizations" : {
@@ -13048,6 +13059,17 @@
         }
       }
     },
+    "adminPromotionStatusUnknown" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Promotion status unknown"
+          }
+        }
+      }
+    },
     "adminRemove" : {
       "extractionState" : "manual",
       "localizations" : {
@@ -193854,6 +193876,17 @@
         }
       }
     },
+    "groupInviteNotSent" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Invite not sent"
+          }
+        }
+      }
+    },
     "groupInviteReinvite" : {
       "extractionState" : "manual",
       "localizations" : {
@@ -194576,6 +194609,17 @@
         }
       }
     },
+    "groupInviteStatusUnknown" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Invite status unknown"
+          }
+        }
+      }
+    },
     "groupInviteSuccessful" : {
       "extractionState" : "manual",
       "localizations" : {

Session/Notifications/NotificationActionHandler.swift

@@ -132,14 +132,21 @@ public class NotificationActionHandler {
         
         return dependencies[singleton: .storage]
             .writePublisher { [dependencies] db -> Network.PreparedRequest<Void> in
+                let sentTimestampMs: Int64 = dependencies[cache: .snodeAPI].currentOffsetTimestampMs()
+                let destinationDisappearingMessagesConfiguration: DisappearingMessagesConfiguration? = try? DisappearingMessagesConfiguration
+                    .filter(id: threadId)
+                    .filter(DisappearingMessagesConfiguration.Columns.isEnabled == true)
+                    .fetchOne(db)
                 let interaction: Interaction = try Interaction(
                     threadId: threadId,
                     threadVariant: thread.variant,
                     authorId: dependencies[cache: .general].sessionId.hexString,
                     variant: .standardOutgoing,
                     body: replyText,
-                    timestampMs: dependencies[cache: .snodeAPI].currentOffsetTimestampMs(),
+                    timestampMs: sentTimestampMs,
                     hasMention: Interaction.isUserMentioned(db, threadId: threadId, body: replyText, using: dependencies),
+                    expiresInSeconds: destinationDisappearingMessagesConfiguration?.durationSeconds,
+                    expiresStartedAtMs: (destinationDisappearingMessagesConfiguration?.type == .disappearAfterSend ? Double(sentTimestampMs) : nil),
                     using: dependencies
                 ).inserted(db)
                 

Session/Notifications/PushRegistrationManager.swift

@@ -275,7 +275,7 @@ public class PushRegistrationManager: NSObject, PKPushRegistryDelegate {
             let timestampMs: UInt64 = payload["timestamp"] as? UInt64,
             TimestampUtils.isWithinOneMinute(timestampMs: timestampMs)
         else {
-            SessionCallManager.reportFakeCall(info: "Missing payload data", using: dependencies) // stringlint:ignore
+            dependencies[singleton: .callManager].reportFakeCall(info: "Missing payload data") // stringlint:ignore
             return
         }
         
@@ -294,17 +294,8 @@ public class PushRegistrationManager: NSObject, PKPushRegistryDelegate {
                     using: dependencies
                 )
                 
-                let thread: SessionThread = try SessionThread.upsert(
-                    db,
-                    id: caller,
-                    variant: .contact,
-                    values: .existingOrDefault,
-                    calledFromConfig: nil,
-                    using: dependencies
-                )
-                
                 let interaction: Interaction? = try Interaction
-                    .filter(Interaction.Columns.threadId == thread.id)
+                    .filter(Interaction.Columns.threadId == caller)
                     .filter(Interaction.Columns.messageUuid == uuid)
                     .fetchOne(db)
                 
@@ -318,7 +309,7 @@ public class PushRegistrationManager: NSObject, PKPushRegistryDelegate {
         }
         
         guard let call: SessionCall = maybeCall else {
-            SessionCallManager.reportFakeCall(info: "Could not retrieve call from database", using: dependencies) // stringlint:ignore
+            dependencies[singleton: .callManager].reportFakeCall(info: "Could not retrieve call from database") // stringlint:ignore
             return
         }
         

Session/Settings/HelpViewModel.swift

@@ -171,14 +171,16 @@ class HelpViewModel: SessionTableViewModel, NavigatableStateHolder, ObservableTa
                 cancelTitle: "Share",
                 cancelStyle: .alert_text,
                 onConfirm: { _ in UIPasteboard.general.string = latestLogFilePath },
-                onCancel: { _ in
-                    HelpViewModel.shareLogsInternal(
-                        viewControllerToDismiss: viewControllerToDismiss,
-                        targetView: targetView,
-                        animated: animated,
-                        using: dependencies,
-                        onShareComplete: onShareComplete
-                    )
+                onCancel: { modal in
+                    modal.dismiss(animated: true) {
+                        HelpViewModel.shareLogsInternal(
+                            viewControllerToDismiss: viewControllerToDismiss,
+                            targetView: targetView,
+                            animated: animated,
+                            using: dependencies,
+                            onShareComplete: onShareComplete
+                        )
+                    }
                 }
             )
         )

SessionMessagingKit/Calls/CallManagerProtocol.swift

@@ -19,6 +19,7 @@ public protocol CallManagerProtocol {
     var currentCall: CurrentCallProtocol? { get }
     
     func setCurrentCall(_ call: CurrentCallProtocol?)
+    func reportFakeCall(info: String)
     func reportIncomingCall(_ call: CurrentCallProtocol, callerName: String, completion: @escaping (Error?) -> Void)
     func reportCurrentCallEnded(reason: CXCallEndedReason?)
     func suspendDatabaseIfCallEndedInBackground()

SessionMessagingKit/Calls/NoopSessionCallManager.swift

@@ -7,6 +7,7 @@ internal struct NoopSessionCallManager: CallManagerProtocol {
     var currentCall: CurrentCallProtocol?
 
     func setCurrentCall(_ call: CurrentCallProtocol?) {}
+    func reportFakeCall(info: String) {}
     func reportIncomingCall(_ call: CurrentCallProtocol, callerName: String, completion: @escaping (Error?) -> Void) {}
     func reportCurrentCallEnded(reason: CXCallEndedReason?) {}
     func suspendDatabaseIfCallEndedInBackground() {}

SessionMessagingKit/Database/Models/Attachment.swift

@@ -643,7 +643,10 @@ extension Attachment {
             // If the filename has not file extension, deduce one
             // from the MIME type.
             if targetFileExtension.isEmpty {
-                targetFileExtension = (UTType(sessionMimeType: mimeType)?.sessionFileExtension ?? UTType.fileExtensionDefault)
+                targetFileExtension = (
+                    UTType(sessionMimeType: mimeType)?.sessionFileExtension(sourceFilename: sourceFilename) ??
+                    UTType.fileExtensionDefault
+                )
             }
             
             targetFileExtension = targetFileExtension.lowercased()
@@ -665,7 +668,7 @@ extension Attachment {
         }
         
         let targetFileExtension: String = (
-            UTType(sessionMimeType: mimeType)?.sessionFileExtension ??
+            UTType(sessionMimeType: mimeType)?.sessionFileExtension(sourceFilename: sourceFilename) ??
             UTType.fileExtensionDefault
         ).lowercased()
         

SessionMessagingKit/Database/Models/LinkPreview.swift

@@ -133,12 +133,17 @@ public extension LinkPreview {
     
     static func generateAttachmentIfPossible(imageData: Data?, type: UTType, using dependencies: Dependencies) throws -> Attachment? {
         guard let imageData: Data = imageData, !imageData.isEmpty else { return nil }
-        guard let fileExtension: String = type.sessionFileExtension else { return nil }
+        guard let fileExtension: String = type.sessionFileExtension(sourceFilename: nil) else { return nil }
         guard let mimeType: String = type.preferredMIMEType else { return nil }
         
         let filePath = dependencies[singleton: .fileManager].temporaryFilePath(fileExtension: fileExtension)
         try imageData.write(to: NSURL.fileURL(withPath: filePath), options: .atomicWrite)
-        let dataSource: DataSourcePath = DataSourcePath(filePath: filePath, shouldDeleteOnDeinit: true, using: dependencies)
+        let dataSource: DataSourcePath = DataSourcePath(
+            filePath: filePath,
+            sourceFilename: nil,
+            shouldDeleteOnDeinit: true,
+            using: dependencies
+        )
         
         return Attachment(contentType: mimeType, dataSource: dataSource, using: dependencies)
     }

SessionMessagingKit/Sending & Receiving/Attachments/SignalAttachment.swift

@@ -269,7 +269,7 @@ public class SignalAttachment: Equatable {
     // can be identified.
     public var mimeType: String {
         guard
-            let fileExtension: String = sourceFilename.map({ $0 as NSString })?.pathExtension,
+            let fileExtension: String = sourceFilename.map({ URL(fileURLWithPath: $0) })?.pathExtension,
             !fileExtension.isEmpty,
             let fileExtensionMimeType: String = UTType(sessionFileExtension: fileExtension)?.preferredMIMEType
         else { return (dataType.preferredMIMEType ?? UTType.mimeTypeDefault) }
@@ -306,9 +306,9 @@ public class SignalAttachment: Equatable {
     // can be identified.
     public var fileExtension: String? {
         guard
-            let fileExtension: String = sourceFilename.map({ $0 as NSString })?.pathExtension,
+            let fileExtension: String = sourceFilename.map({ URL(fileURLWithPath: $0) })?.pathExtension,
             !fileExtension.isEmpty
-        else { return dataType.sessionFileExtension }
+        else { return dataType.sessionFileExtension(sourceFilename: sourceFilename) }
         
         return fileExtension.filteredFilename
     }
@@ -807,7 +807,7 @@ public class SignalAttachment: Equatable {
                     let baseFilename = dataSource.sourceFilename
                     let mp4Filename = baseFilename?.filenameWithoutExtension.appendingFileExtension("mp4")
                     
-                    guard let dataSource = DataSourcePath(fileUrl: exportURL, shouldDeleteOnDeinit: true, using: dependencies) else {
+                    guard let dataSource = DataSourcePath(fileUrl: exportURL, sourceFilename: baseFilename, shouldDeleteOnDeinit: true, using: dependencies) else {
                         let attachment = SignalAttachment(dataSource: DataSourceValue.empty(using: dependencies), dataType: type)
                         attachment.error = .couldNotConvertToMpeg4
                         resolver(Result.success(attachment))

SessionMessagingKit/Sending & Receiving/Message Handling/MessageReceiver+LegacyClosedGroups.swift

@@ -143,6 +143,7 @@ extension MessageReceiver {
         // approved contact (to prevent spam via closed groups getting around message requests if users are
         // on old or modified clients)
         var hasApprovedAdmin: Bool = false
+        let receivedTimestamp: TimeInterval = (dependencies[cache: .snodeAPI].currentOffsetTimestampMs() / 1000)
         
         for adminId in admins {
             if let contact: Contact = try? Contact.fetchOne(db, id: adminId), contact.isApproved {
@@ -156,6 +157,36 @@ extension MessageReceiver {
         // antoher device)
         guard hasApprovedAdmin || configTriggeringChange != nil else { return }
         
+        // Create the disappearing config
+        let disappearingConfig: DisappearingMessagesConfiguration = DisappearingMessagesConfiguration
+            .defaultWith(legacyGroupSessionId)
+            .with(
+                isEnabled: (expirationTimer > 0),
+                durationSeconds: TimeInterval(expirationTimer),
+                type: (expirationTimer > 0 ? .disappearAfterSend : .unknown)
+            )
+        
+        /// Update `libSession` first
+        ///
+        /// **Note:** This **MUST** happen before we call `SessionThread.upsert` as we won't add the group
+        /// if it already exists in `libSession` and upserting the thread results in an update to `libSession` to set
+        /// the `priority`
+        if configTriggeringChange == nil {
+            try? LibSession.add(
+                db,
+                legacyGroupSessionId: legacyGroupSessionId,
+                name: name,
+                joinedAt: (TimeInterval(formationTimestampMs) / 1000),
+                latestKeyPairPublicKey: Data(encryptionKeyPair.publicKey),
+                latestKeyPairSecretKey: Data(encryptionKeyPair.secretKey),
+                latestKeyPairReceivedTimestamp: receivedTimestamp,
+                disappearingConfig: disappearingConfig,
+                members: members.asSet(),
+                admins: admins.asSet(),
+                using: dependencies
+            )
+        }
+        
         // Create the group
         let thread: SessionThread = try SessionThread.upsert(
             db,
@@ -203,20 +234,11 @@ extension MessageReceiver {
         }
         
         // Update the DisappearingMessages config
-        var disappearingConfig = DisappearingMessagesConfiguration.defaultWith(thread.id)
         if (try? thread.disappearingMessagesConfiguration.fetchOne(db)) == nil {
-            let isEnabled: Bool = (expirationTimer > 0)
-            disappearingConfig = try disappearingConfig
-                .with(
-                    isEnabled: isEnabled,
-                    durationSeconds: TimeInterval(expirationTimer),
-                    type: isEnabled ? .disappearAfterSend : .unknown
-                )
-                .saved(db)
+            try disappearingConfig.upsert(db)
         }
         
         // Store the key pair if it doesn't already exist
-        let receivedTimestamp: TimeInterval = (dependencies[cache: .snodeAPI].currentOffsetTimestampMs() / 1000)
         let newKeyPair: ClosedGroupKeyPair = ClosedGroupKeyPair(
             threadId: legacyGroupSessionId,
             publicKey: Data(encryptionKeyPair.publicKey),

SessionMessagingKit/Sending & Receiving/Message Handling/MessageSender+LegacyClosedGroups.swift

@@ -39,6 +39,25 @@ extension MessageSender {
                 let adminsAsData: [Data] = admins.map { Data(hex: $0) }
                 let formationTimestamp: TimeInterval = (dependencies[cache: .snodeAPI].currentOffsetTimestampMs() / 1000)
                 
+                /// Update `libSession` first
+                ///
+                /// **Note:** This **MUST** happen before we call `SessionThread.upsert` as we won't add the group
+                /// if it already exists in `libSession` and upserting the thread results in an update to `libSession` to set
+                /// the `priority`
+                try LibSession.add(
+                    db,
+                    legacyGroupSessionId: legacyGroupSessionId,
+                    name: name,
+                    joinedAt: formationTimestamp,
+                    latestKeyPairPublicKey: Data(encryptionKeyPair.publicKey),
+                    latestKeyPairSecretKey: Data(encryptionKeyPair.secretKey),
+                    latestKeyPairReceivedTimestamp: formationTimestamp,
+                    disappearingConfig: DisappearingMessagesConfiguration.defaultWith(legacyGroupSessionId),
+                    members: members,
+                    admins: admins,
+                    using: dependencies
+                )
+                
                 // Create the relevant objects in the database
                 let thread: SessionThread = try SessionThread.upsert(
                     db,
@@ -88,21 +107,6 @@ extension MessageSender {
                     ).upsert(db)
                 }
                 
-                // Update libSession
-                try LibSession.add(
-                    db,
-                    legacyGroupSessionId: legacyGroupSessionId,
-                    name: name,
-                    joinedAt: formationTimestamp,
-                    latestKeyPairPublicKey: Data(encryptionKeyPair.publicKey),
-                    latestKeyPairSecretKey: Data(encryptionKeyPair.secretKey),
-                    latestKeyPairReceivedTimestamp: formationTimestamp,
-                    disappearingConfig: DisappearingMessagesConfiguration.defaultWith(legacyGroupSessionId),
-                    members: members,
-                    admins: admins,
-                    using: dependencies
-                )
-                
                 let memberSendData: [Network.PreparedRequest<Void>] = try members
                     .map { memberId -> Network.PreparedRequest<Void> in
                         try MessageSender.preparedSend(

SessionNotificationServiceExtension/NotificationServiceExtension.swift

@@ -102,7 +102,10 @@ public final class NotificationServiceExtension: UNNotificationServiceExtension
             }
         }
         
-        let isCallOngoing: Bool = dependencies[defaults: .appGroup, key: .isCallOngoing]
+        let isCallOngoing: Bool = (
+            dependencies[defaults: .appGroup, key: .isCallOngoing] &&
+            (dependencies[defaults: .appGroup, key: .lastCallPreOffer] != nil)
+        )
         
         // HACK: It is important to use write synchronously here to avoid a race condition
         // where the completeSilenty() is called before the local notification request

SessionShareExtension/ShareNavController.swift

@@ -258,15 +258,12 @@ final class ShareNavController: UINavigationController, ShareViewDelegate {
             //
             // NOTE: SharingThreadPickerViewController will try to unpack them
             //       and send them as normal text messages if possible.
-            case (_, true): return DataSourcePath(fileUrl: url, shouldDeleteOnDeinit: false, using: dependencies)
+            case (_, true): return DataSourcePath(fileUrl: url, sourceFilename: customFileName, shouldDeleteOnDeinit: false, using: dependencies)
             
             default:
-                guard let dataSource = DataSourcePath(fileUrl: url, shouldDeleteOnDeinit: false, using: dependencies) else {
+                guard let dataSource = DataSourcePath(fileUrl: url, sourceFilename: customFileName, shouldDeleteOnDeinit: false, using: dependencies) else {
                     return nil
                 }
-
-                // Fallback to the last part of the URL
-                dataSource.sourceFilename = (customFileName ?? url.lastPathComponent)
                 
                 return dataSource
         }
@@ -413,7 +410,7 @@ final class ShareNavController: UINavigationController, ShareViewDelegate {
                     switch value {
                         case let data as Data:
                             let customFileName = "Contact.vcf" // stringlint:ignore
-                            let customFileExtension: String? = srcType.sessionFileExtension
+                            let customFileExtension: String? = srcType.sessionFileExtension(sourceFilename: nil)
                             
                             guard let tempFilePath = try? dependencies[singleton: .fileManager].write(data: data, toTemporaryFileWithExtension: customFileExtension) else {
                                 resolver(

SessionShareExtension/ThreadPickerVC.swift

@@ -287,14 +287,21 @@ final class ThreadPickerVC: UIViewController, UITableViewDataSource, UITableView
                     }
                     
                     // Create the interaction
+                    let sentTimestampMs: Int64 = dependencies[cache: .snodeAPI].currentOffsetTimestampMs()
+                    let destinationDisappearingMessagesConfiguration: DisappearingMessagesConfiguration? = try? DisappearingMessagesConfiguration
+                        .filter(id: threadId)
+                        .filter(DisappearingMessagesConfiguration.Columns.isEnabled == true)
+                        .fetchOne(db)
                     let interaction: Interaction = try Interaction(
                         threadId: threadId,
                         threadVariant: threadVariant,
                         authorId: userSessionId.hexString,
                         variant: .standardOutgoing,
                         body: body,
-                        timestampMs: dependencies[cache: .snodeAPI].currentOffsetTimestampMs(),
+                        timestampMs: sentTimestampMs,
                         hasMention: Interaction.isUserMentioned(db, threadId: threadId, body: body, using: dependencies),
+                        expiresInSeconds: destinationDisappearingMessagesConfiguration?.durationSeconds,
+                        expiresStartedAtMs: (destinationDisappearingMessagesConfiguration?.type == .disappearAfterSend ? Double(sentTimestampMs) : nil),
                         linkPreviewUrl: (isSharingUrl ? attachments.first?.linkPreviewDraft?.urlString : nil),
                         using: dependencies
                     ).inserted(db)

SessionUtilitiesKit/Media/DataSource.swift

@@ -101,7 +101,7 @@ public class DataSourceValue: DataSource {
     }
     
     public convenience init?(data: Data?, dataType: UTType, using dependencies: Dependencies) {
-        guard let fileExtension: String = dataType.sessionFileExtension else { return nil }
+        guard let fileExtension: String = dataType.sessionFileExtension(sourceFilename: nil) else { return nil }
         
         self.init(data: data, fileExtension: fileExtension, using: dependencies)
     }
@@ -216,16 +216,32 @@ public class DataSourcePath: DataSource {
 
     // MARK: - Initialization
     
-    public init(filePath: String, shouldDeleteOnDeinit: Bool, using dependencies: Dependencies) {
+    public init(
+        filePath: String,
+        sourceFilename: String?,
+        shouldDeleteOnDeinit: Bool,
+        using dependencies: Dependencies
+    ) {
         self.dependencies = dependencies
         self.filePath = filePath
+        self.sourceFilename = sourceFilename
         self.shouldDeleteOnDeinit = shouldDeleteOnDeinit
     }
     
-    public convenience init?(fileUrl: URL?, shouldDeleteOnDeinit: Bool, using dependencies: Dependencies) {
+    public convenience init?(
+        fileUrl: URL?,
+        sourceFilename: String?,
+        shouldDeleteOnDeinit: Bool,
+        using dependencies: Dependencies
+    ) {
         guard let fileUrl: URL = fileUrl, fileUrl.isFileURL else { return nil }
         
-        self.init(filePath: fileUrl.path, shouldDeleteOnDeinit: shouldDeleteOnDeinit, using: dependencies)
+        self.init(
+            filePath: fileUrl.path,
+            sourceFilename: (sourceFilename ?? fileUrl.lastPathComponent),
+            shouldDeleteOnDeinit: shouldDeleteOnDeinit,
+            using: dependencies
+        )
     }
     
     deinit {

SignalUtilitiesKit/Media Viewing & Editing/Attachment Approval/AttachmentApprovalViewController.swift

@@ -542,7 +542,7 @@ public class AttachmentApprovalViewController: UIPageViewController, UIPageViewC
         // Rewrite the filename's extension to reflect the output file format.
         var filename: String? = attachmentItem.attachment.sourceFilename
         if let sourceFilename = attachmentItem.attachment.sourceFilename {
-            if let fileExtension: String = dataType.sessionFileExtension {
+            if let fileExtension: String = dataType.sessionFileExtension(sourceFilename: sourceFilename) {
                 filename = (sourceFilename as NSString).deletingPathExtension.appendingFileExtension(fileExtension)
             }
         }