feat: Handle downloads from WKWebView (#54)

Author: valentinperignon

EuriaCore/Extensions/URL+Extension.swift

@@ -0,0 +1,27 @@
+/*
+ Infomaniak Euria - iOS App
+ Copyright (C) 2025 Infomaniak Network SA
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import Foundation
+
+public extension URL {
+    static func temporaryDownloadsDirectory() throws -> URL {
+        let temporaryFolder = URL.temporaryDirectory.appending(path: "/euria_downloads", directoryHint: .isDirectory)
+        try FileManager.default.createDirectory(at: temporaryFolder, withIntermediateDirectories: true)
+        return temporaryFolder
+    }
+}

EuriaFeatures/MainView/EuriaWebViewDelegate.swift

@@ -20,6 +20,7 @@ import EuriaCore
 import InfomaniakCore
 import InfomaniakDI
 import InfomaniakLogin
+import OSLog
 import Sentry
 import SwiftUI
 import UIKit
@@ -29,19 +30,54 @@ import WebKit
 class EuriaWebViewDelegate: NSObject, ObservableObject {
     @Published var isLoaded = false
 
+    @Published var isPresentingDocument: URL?
+    @Published var error: ErrorDomain?
+
     let webConfiguration: WKWebViewConfiguration
+    var downloads = [WKDownload: URL]()
 
     enum Cookie: String {
         case userToken = "USER-TOKEN"
         case userLanguage = "USER-LANGUAGE"
     }
 
+    enum ErrorDomain: LocalizedError, Equatable {
+        case urlGenerationFailed(error: Error)
+        case downloadFailed(error: Error)
+
+        var errorDescription: String? {
+            switch self {
+            case .urlGenerationFailed(let error):
+                return error.localizedDescription
+            case .downloadFailed(let error):
+                return error.localizedDescription
+            }
+        }
+
+        static func == (lhs: ErrorDomain, rhs: ErrorDomain) -> Bool {
+            switch (lhs, rhs) {
+            case (.urlGenerationFailed, .urlGenerationFailed):
+                return true
+            case (.downloadFailed, .downloadFailed):
+                return true
+            default:
+                return false
+            }
+        }
+    }
+
     init(session: any UserSessionable) {
         webConfiguration = WKWebViewConfiguration()
         super.init()
         setupWebViewConfiguration(token: session.apiFetcher.currentToken)
     }
 
+    deinit {
+        Task {
+            await EuriaWebViewDelegate.cleanTemporaryFolder()
+        }
+    }
+
     private func setupWebViewConfiguration(token: ApiToken?) {
         addCookies(token: token)
         addUserContentControllers()
@@ -77,35 +113,82 @@ class EuriaWebViewDelegate: NSObject, ObservableObject {
             ]
         )
     }
+
+    private nonisolated static func cleanTemporaryFolder() async {
+        do {
+            try FileManager.default.removeItem(at: URL.temporaryDownloadsDirectory())
+        } catch {
+            Logger.general.error("Error while cleaning temporary folder: \(error)")
+        }
+    }
 }
 
 // MARK: - WKNavigationDelegate
 
 extension EuriaWebViewDelegate: WKNavigationDelegate {
-    func webView(
-        _ webView: WKWebView,
-        decidePolicyFor navigationAction: WKNavigationAction,
-        decisionHandler: @MainActor (WKNavigationActionPolicy) -> Void
-    ) {
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction) async -> WKNavigationActionPolicy {
+        guard !navigationAction.shouldPerformDownload else {
+            return .download
+        }
+
         guard let navigationHost = navigationAction.request.url?.host() else {
-            decisionHandler(.allow)
-            return
+            return .allow
         }
 
         if navigationHost == ApiEnvironment.current.euriaHost {
-            decisionHandler(.allow)
-        } else {
-            if navigationAction.navigationType == .linkActivated,
-               let url = navigationAction.request.url {
-                UIApplication.shared.open(url)
-            }
-            decisionHandler(.cancel)
+            return .allow
         }
+
+        if navigationAction.navigationType == .linkActivated, let url = navigationAction.request.url {
+            await UIApplication.shared.open(url)
+        }
+        return .cancel
     }
 
     func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
         isLoaded = true
     }
+
+    func webView(_ webView: WKWebView, navigationAction: WKNavigationAction, didBecome download: WKDownload) {
+        download.delegate = self
+    }
+}
+
+// MARK: - WKDownloadDelegate
+
+extension EuriaWebViewDelegate: WKDownloadDelegate {
+    func download(_ download: WKDownload, decideDestinationUsing response: URLResponse, suggestedFilename: String) async -> URL? {
+        do {
+            let fileDestinationURL = try URL.temporaryDownloadsDirectory().appending(path: suggestedFilename)
+            guard !FileManager.default.fileExists(atPath: fileDestinationURL.path(percentEncoded: false)) else {
+                isPresentingDocument = fileDestinationURL
+                return nil
+            }
+
+            downloads[download] = fileDestinationURL
+            return fileDestinationURL
+        } catch {
+            self.error = .urlGenerationFailed(error: error)
+            Logger.general.error("Error while generating the destination URL for a download: \(error)")
+            return nil
+        }
+    }
+
+    func downloadDidFinish(_ download: WKDownload) {
+        guard let fileURL = downloads[download] else {
+            return
+        }
+
+        isPresentingDocument = fileURL
+        downloads[download] = nil
+    }
+
+    func download(_ download: WKDownload, didFailWithError error: any Error, resumeData: Data?) {
+        self.error = .downloadFailed(error: error)
+        Logger.general.error("Error while downloading a file: \(error)")
+
+        downloads[download] = nil
+    }
 }
 
 // MARK: - WKScriptMessageHandler

EuriaFeatures/MainView/MainView.swift

@@ -23,14 +23,17 @@ import InAppTwoFactorAuthentication
 import InfomaniakConcurrency
 import InfomaniakCore
 import InfomaniakCoreCommonUI
+import InfomaniakCoreUIResources
 import InfomaniakDI
 import InfomaniakLogin
 import SwiftUI
 import WebKit
 
 public struct MainView: View {
     @StateObject private var webViewDelegate: EuriaWebViewDelegate
+
     @State private var isShowingWebView = true
+    @State private var isShowingErrorAlert = false
 
     @ObservedObject var networkMonitor = NetworkMonitor.shared
 
@@ -55,6 +58,16 @@ public struct MainView: View {
                     delegate: webViewDelegate
                 )
                 .ignoresSafeArea()
+                .quickLookPreview($webViewDelegate.isPresentingDocument)
+                .onChange(of: webViewDelegate.error) { newValue in
+                    guard newValue != nil else { return }
+                    isShowingErrorAlert = true
+                }
+                .alert(isPresented: $isShowingErrorAlert, error: webViewDelegate.error) {
+                    Button(InfomaniakCoreUIResources.CoreUILocalizable.buttonClose) {
+                        webViewDelegate.error = nil
+                    }
+                }
             }
 
             if isShowingOfflineView {