feat: Attachment title will be used to populate Draft Subject

Mail/Views/New Message/Attachments/Attachable.swift

@@ -38,27 +38,32 @@ extension NSItemProvider: Attachable {
         return UTType(preferredIdentifier)
     }
 
-    public func writeToTemporaryURL() async throws -> URL {
+    public func writeToTemporaryURL() async throws -> (url: URL, title: String?) {
         switch underlyingType {
         case .isURL:
             let getPlist = try ItemProviderURLRepresentation(from: self)
-            return try await getPlist.result.get().url
+            let result = try await getPlist.result.get()
+            return (result.url, result.title)
 
         case .isText:
             let getText = try ItemProviderTextRepresentation(from: self)
-            return try await getText.result.get()
+            let resultURL = try await getText.result.get()
+            return (resultURL, nil)
 
         case .isUIImage:
             let getUIImage = try ItemProviderUIImageRepresentation(from: self)
-            return try await getUIImage.result.get()
+            let resultURL = try await getUIImage.result.get()
+            return (resultURL, nil)
 
         case .isImageData, .isCompressedData, .isMiscellaneous:
             let getFile = try ItemProviderFileRepresentation(from: self)
-            return try await getFile.result.get().url
+            let result = try await getFile.result.get()
+            return (result.url, result.title)
 
         case .isDirectory:
             let getFile = try ItemProviderZipRepresentation(from: self)
-            return try await getFile.result.get().url
+            let result = try await getFile.result.get()
+            return (result.url, result.title)
 
         case .none:
             throw ErrorDomain.UTINotFound
@@ -75,7 +80,7 @@ extension PHPickerResult: Attachable {
         return itemProvider.type
     }
 
-    public func writeToTemporaryURL() async throws -> URL {
+    public func writeToTemporaryURL() async throws -> (url: URL, title: String?) {
         return try await itemProvider.writeToTemporaryURL()
     }
 }
@@ -89,8 +94,8 @@ extension URL: Attachable {
         return UTType.data
     }
 
-    public func writeToTemporaryURL() async throws -> URL {
-        return self
+    public func writeToTemporaryURL() async throws -> (url: URL, title: String?) {
+        return (self, nil)
     }
 }
 
@@ -103,11 +108,11 @@ extension Data: Attachable {
         return UTType.image
     }
 
-    public func writeToTemporaryURL() async throws -> URL {
+    public func writeToTemporaryURL() async throws -> (url: URL, title: String?) {
         let temporaryURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         let temporaryFileURL = temporaryURL.appendingPathComponent("attachment").appendingPathExtension("jpeg")
         try FileManager.default.createDirectory(at: temporaryURL, withIntermediateDirectories: true)
         try write(to: temporaryFileURL)
-        return temporaryFileURL
+        return (temporaryFileURL, nil)
     }
 }

MailCore/Cache/AttachmentsManagerWorker/AttachmentsManagerWorker.swift

@@ -26,7 +26,7 @@ import UniformTypeIdentifiers
 public protocol Attachable {
     var suggestedName: String? { get }
     var type: UTType? { get }
-    func writeToTemporaryURL() async throws -> URL
+    func writeToTemporaryURL() async throws -> (url: URL, title: String?)
 }
 
 /// Abstracts that some attachment was updated
@@ -88,6 +88,25 @@ public final class AttachmentsManagerWorker {
         liveAttachments.map { $0.detached() }
     }
 
+    var attachmentsTitles: [String?]? {
+        didSet {
+            let realm = backgroundRealm.getRealm()
+            guard let draft = realm.object(ofType: Draft.self, forPrimaryKey: draftLocalUUID),
+                  !draft.isInvalidated,
+                  draft.subject.isEmpty else {
+                return
+            }
+
+            guard let attachmentTitle = attachmentsTitles?.compactMap({ $0 }).first else {
+                return
+            }
+
+            try? realm.write {
+                draft.subject = attachmentTitle
+            }
+        }
+    }
+
     public init(backgroundRealm: BackgroundRealm, draftLocalUUID: String, mailboxManager: MailboxManager) {
         self.backgroundRealm = backgroundRealm
         self.draftLocalUUID = draftLocalUUID
@@ -165,7 +184,6 @@ public final class AttachmentsManagerWorker {
         await updateDelegate?.contentWillChange()
     }
 
-    @discardableResult
     func importAttachment(attachment: Attachable, disposition: AttachmentDisposition) async -> String? {
         guard let localAttachment = await createLocalAttachment(name: attachment.suggestedName ?? getDefaultFileName(),
                                                                 type: attachment.type,
@@ -175,27 +193,26 @@ public final class AttachmentsManagerWorker {
 
         let importTask = Task { () -> String? in
             do {
-                let url = try await attachment.writeToTemporaryURL()
-                let updatedAttachment = await updateLocalAttachment(url: url, attachment: localAttachment)
+                let attachmentResult = try await attachment.writeToTemporaryURL()
+                let attachmentURL = attachmentResult.url
+                let attachmentTitle = attachmentResult.title
+
+                let updatedAttachment = await updateLocalAttachment(url: attachmentURL, attachment: localAttachment)
                 let totalSize = liveAttachments.map(\.size).reduce(0) { $0 + $1 }
                 guard totalSize < Constants.maxAttachmentsSize else {
                     await updateDelegate?.handleGlobalError(MailError.attachmentsSizeLimitReached)
                     await removeAttachment(updatedAttachment.uuid)
                     return nil
                 }
 
-                let remoteAttachment = try await sendAttachment(url: url, localAttachment: updatedAttachment)
+                try await sendAttachment(url: attachmentURL, localAttachment: updatedAttachment)
+                return attachmentTitle
 
-                if disposition == .inline,
-                   let cid = remoteAttachment?.contentId {
-                    return cid
-                }
             } catch {
                 DDLogError("Error while creating attachment: \(error.localizedDescription)")
                 await updateAttachmentUploadError(localAttachment, error: error)
+                return nil
             }
-
-            return nil
         }
 
         if let uploadTask = attachmentUploadTasks[localAttachment.uuid] {
@@ -220,6 +237,7 @@ public final class AttachmentsManagerWorker {
         return savedAttachment
     }
 
+    @discardableResult
     func sendAttachment(url: URL, localAttachment: Attachment) async throws -> Attachment? {
         let data = try Data(contentsOf: url)
         let remoteAttachment = try await mailboxManager.apiFetcher.createAttachment(
@@ -301,18 +319,23 @@ extension AttachmentsManagerWorker: AttachmentsManagerWorkable {
         self.updateDelegate = updateDelegate
     }
 
-    public func importAttachments(attachments: [Attachable], draft: Draft, disposition: AttachmentDisposition) async {
+    public func importAttachments(attachments: [Attachable],
+                                  draft: Draft,
+                                  disposition: AttachmentDisposition) async {
         guard !attachments.isEmpty else {
             return
         }
 
         // Cap max number of attachments, API errors out at 100
         let attachmentsSlice = attachments[safe: 0 ..< draft.availableAttachmentsSlots]
 
-        await attachmentsSlice.concurrentForEach { attachment in
-            await self.importAttachment(attachment: attachment, disposition: disposition)
+        let titles: [String?] = await attachmentsSlice.concurrentMap { attachment in
+            let title = await self.importAttachment(attachment: attachment, disposition: disposition)
             // TODO: - Manage inline attachment
+            return title
         }
+
+        attachmentsTitles = titles
     }
 
     public func removeAttachment(_ attachmentUUID: String) async {