feat: External links feature branch

kDrive/AppDelegate.swift

@@ -103,6 +103,18 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
         }
         application.registerForRemoteNotifications()
 
+        // swiftlint:disable force_try
+        Task {
+            try! await Task.sleep(nanoseconds:5_000_000_000)
+            print("coucou")
+            let somePublicShare = URL(string: "")
+            //await UIApplication.shared.open(somePublicShare!) // opens safari
+
+            let components = URLComponents(url: somePublicShare!, resolvingAgainstBaseURL: true)
+            await UniversalLinksHelper.handlePath(components!.path)
+        }
+
+
         return true
     }
 

kDrive/AppRouter.swift

@@ -584,6 +584,26 @@ public struct AppRouter: AppNavigable {
 
     // MARK: RouterFileNavigable
 
+    @MainActor public func presentPublicShare(
+        rootFolder: File,
+        publicShareProxy: PublicShareProxy,
+        driveFileManager: DriveFileManager,
+        apiFetcher: PublicShareApiFetcher
+    ) {
+        // TODO: Present on top of existing views
+        guard let window,
+              let rootViewController = window.rootViewController else {
+            fatalError("TODO: lazy load a rootViewController")
+        }
+
+        let filePresenter = FilePresenter(viewController: rootViewController)
+        filePresenter.presentPublicShareDirectory(publicShareProxy: publicShareProxy,
+                                                  rootFolder: rootFolder,
+                                                  rootViewController: rootViewController,
+                                                  driveFileManager: driveFileManager,
+                                                  apiFetcher: apiFetcher)
+    }
+
     @MainActor public func present(file: File, driveFileManager: DriveFileManager) {
         present(file: file, driveFileManager: driveFileManager, office: false)
     }

kDrive/SceneDelegate.swift

@@ -230,13 +230,15 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate, AccountManagerDel
 
     func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
         Log.sceneDelegate("scene continue userActivity")
-        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
-              let incomingURL = userActivity.webpageURL,
-              let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: true) else {
-            return
-        }
+        Task {
+            guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+                  let incomingURL = userActivity.webpageURL,
+                  let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: true) else {
+                return
+            }
 
-        UniversalLinksHelper.handlePath(components.path)
+            await UniversalLinksHelper.handlePath(components.path)
+        }
     }
 
     func scene(_ scene: UIScene, didFailToContinueUserActivityWithType userActivityType: String, error: Error) {

kDrive/UI/Controller/Files/FilePresenter.swift

@@ -132,6 +132,31 @@ final class FilePresenter {
         }
     }
 
+    public func presentPublicShareDirectory(
+        publicShareProxy: PublicShareProxy,
+        rootFolder: File,
+        rootViewController: UIViewController,
+        driveFileManager: DriveFileManager,
+        apiFetcher: PublicShareApiFetcher
+    ) {
+        let viewModel = PublicShareViewModel(publicShareProxy: publicShareProxy,
+                                             sortType: .nameAZ,
+                                             driveFileManager: driveFileManager,
+                                             currentDirectory: rootFolder,
+                                             apiFetcher: apiFetcher)
+
+        // TODO: Fix access right
+//        guard !rootFolder.isDisabled else {
+//            return
+//        }
+
+        let nextVC = FileListViewController(viewModel: viewModel)
+        print("nextVC:\(nextVC) viewModel:\(viewModel) navigationController:\(navigationController)")
+//        navigationController?.pushViewController(nextVC, animated: true)
+
+        rootViewController.present(nextVC, animated: true)
+    }
+
     public func presentDirectory(
         for file: File,
         driveFileManager: DriveFileManager,

kDrive/UI/Controller/Menu/SharedWithMe/SharedWithMeViewModel.swift

@@ -20,6 +20,69 @@ import kDriveCore
 import RealmSwift
 import UIKit
 
+/// Public share view model, loading content from memory realm
+final class PublicShareViewModel: InMemoryFileListViewModel {
+    var publicShareProxy: PublicShareProxy?
+    let rootProxy: ProxyFile
+    var publicShareApiFetcher: PublicShareApiFetcher?
+
+    required init(driveFileManager: DriveFileManager, currentDirectory: File? = nil) {
+        guard let currentDirectory else {
+            fatalError("woops")
+        }
+
+        let configuration = Configuration(selectAllSupported: false,
+                                          rootTitle: "public share",
+                                          emptyViewType: .emptyFolder,
+                                          supportsDrop: false,
+                                          matomoViewPath: [MatomoUtils.Views.menu.displayName, "publicShare"])
+
+        rootProxy = currentDirectory.proxify()
+        super.init(configuration: configuration, driveFileManager: driveFileManager, currentDirectory: currentDirectory)
+        observedFiles = AnyRealmCollection(currentDirectory.children)
+        print("• observedFiles :\(observedFiles.count)")
+    }
+
+    convenience init(
+        publicShareProxy: PublicShareProxy,
+        sortType: SortType,
+        driveFileManager: DriveFileManager,
+        currentDirectory: File,
+        apiFetcher: PublicShareApiFetcher
+    ) {
+        self.init(driveFileManager: driveFileManager, currentDirectory: currentDirectory)
+        self.publicShareProxy = publicShareProxy
+        self.sortType = sortType
+        publicShareApiFetcher = apiFetcher
+    }
+
+    override func loadFiles(cursor: String? = nil, forceRefresh: Bool = false) async throws {
+        print("• loadFiles:\(cursor):\(forceRefresh)")
+        guard !isLoading || cursor != nil,
+              let publicShareProxy,
+              let publicShareApiFetcher else {
+            return
+        }
+
+        // Only show loading indicator if we have nothing in cache
+        if !currentDirectory.canLoadChildrenFromCache {
+            startRefreshing(cursor: cursor)
+        }
+        defer {
+            endRefreshing()
+        }
+
+        let (_, nextCursor) = try await driveFileManager.publicShareFiles(rootProxy: rootProxy,
+                                                                          publicShareProxy: publicShareProxy,
+                                                                          publicShareApiFetcher: publicShareApiFetcher)
+        print("• nextCursor:\(nextCursor)")
+        endRefreshing()
+        if let nextCursor {
+            try await loadFiles(cursor: nextCursor)
+        }
+    }
+}
+
 class SharedWithMeViewModel: FileListViewModel {
     required init(driveFileManager: DriveFileManager, currentDirectory: File? = nil) {
         let sharedWithMeRootFile = driveFileManager.getManagedFile(from: DriveFileManager.sharedWithMeRootFile)

kDrive/Utils/UniversalLinksHelper.swift

@@ -35,26 +35,44 @@ enum UniversalLinksHelper {
             regex: Regex(pattern: #"^/app/drive/([0-9]+)/redirect/([0-9]+)$"#)!,
             displayMode: .file
         )
+
+        /// Matches a public share link
+        static let publicShareLink = Link(
+            regex: Regex(pattern: #"^/app/share/([0-9]+)/([a-z0-9-]+)$"#)!,
+            displayMode: .file
+        )
+
         /// Matches a directory list link
         static let directoryLink = Link(regex: Regex(pattern: #"^/app/drive/([0-9]+)/files/([0-9]+)$"#)!, displayMode: .file)
+
         /// Matches a file preview link
         static let filePreview = Link(
             regex: Regex(pattern: #"^/app/drive/([0-9]+)/files/([0-9]+/)?preview/[a-z]+/([0-9]+)$"#)!,
             displayMode: .file
         )
+
         /// Matches an office file link
         static let officeLink = Link(regex: Regex(pattern: #"^/app/office/([0-9]+)/([0-9]+)$"#)!, displayMode: .office)
 
-        static let all = [privateShareLink, directoryLink, filePreview, officeLink]
+        static let all = [privateShareLink, publicShareLink, directoryLink, filePreview, officeLink]
     }
 
     private enum DisplayMode {
         case office, file
     }
 
-    static func handlePath(_ path: String) -> Bool {
+    @discardableResult
+    static func handlePath(_ path: String) async -> Bool {
         DDLogInfo("[UniversalLinksHelper] Trying to open link with path: \(path)")
 
+        // Public share link regex
+        let shareLink = Link.publicShareLink
+        let matches = shareLink.regex.matches(in: path)
+        if await processPublicShareLink(matches: matches, displayMode: shareLink.displayMode) {
+            return true
+        }
+
+        // Common regex
         for link in Link.all {
             let matches = link.regex.matches(in: path)
             if processRegex(matches: matches, displayMode: link.displayMode) {
@@ -66,6 +84,33 @@ enum UniversalLinksHelper {
         return false
     }
 
+    private static func processPublicShareLink(matches: [[String]], displayMode: DisplayMode) async -> Bool {
+        @InjectService var accountManager: AccountManageable
+
+        guard let firstMatch = matches.first,
+              let driveId = firstMatch[safe: 1],
+              let driveIdInt = Int(driveId),
+              let shareLinkUid = firstMatch[safe: 2] else {
+            return false
+        }
+
+        // request metadata
+        let apiFetcher = PublicShareApiFetcher()
+        guard let metadata = try? await apiFetcher.getMetadata(driveId: driveIdInt, shareLinkUid: shareLinkUid)
+        else {
+            return false
+        }
+
+        // get file ID from metadata
+        let publicShareDriveFileManager = accountManager.getInMemoryDriveFileManager(for: shareLinkUid)
+        openPublicShare(driveId: driveIdInt,
+                        linkUuid: shareLinkUid,
+                        fileId: metadata.fileId,
+                        driveFileManager: publicShareDriveFileManager,
+                        apiFetcher: apiFetcher)
+        return true
+    }
+
     private static func processRegex(matches: [[String]], displayMode: DisplayMode) -> Bool {
         @InjectService var accountManager: AccountManageable
 
@@ -83,6 +128,33 @@ enum UniversalLinksHelper {
         return true
     }
 
+    private static func openPublicShare(driveId: Int,
+                                        linkUuid: String,
+                                        fileId: Int,
+                                        driveFileManager: DriveFileManager,
+                                        apiFetcher: PublicShareApiFetcher) {
+        Task {
+            do {
+                let rootFolder = try await apiFetcher.getShareLinkFile(driveId: driveId,
+                                                                       linkUuid: linkUuid,
+                                                                       fileId: fileId)
+                @InjectService var appNavigable: AppNavigable
+                let publicShareProxy = PublicShareProxy(driveId: driveId, fileId: fileId, shareLinkUid: linkUuid)
+                await appNavigable.presentPublicShare(
+                    rootFolder: rootFolder,
+                    publicShareProxy: publicShareProxy,
+                    driveFileManager: driveFileManager,
+                    apiFetcher: apiFetcher
+                )
+            } catch {
+                DDLogError(
+                    "[UniversalLinksHelper] Failed to get public folder [driveId:\(driveId) linkUuid:\(linkUuid) fileId:\(fileId)]: \(error)"
+                )
+                await UIConstants.showSnackBarIfNeeded(error: error)
+            }
+        }
+    }
+
     private static func openFile(id: Int, driveFileManager: DriveFileManager, office: Bool) {
         Task {
             do {

kDriveCore/Data/Api/DriveApiFetcher.swift

@@ -52,6 +52,54 @@ public class AuthenticatedImageRequestModifier: ImageDownloadRequestModifier {
     }
 }
 
+public struct PublicShareMetadata: Decodable {
+    public let url: URL
+    public let fileId: Int
+    public let right: String
+
+    public let validUntil: TimeInterval?
+    public let capabilities: Rights
+
+    public let createdBy: TimeInterval
+    public let createdAt: TimeInterval
+    public let updatedAt: TimeInterval
+    public let accessBlocked: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case url
+        case fileId
+        case right
+        case validUntil
+        case capabilities
+        case createdBy
+        case createdAt
+        case updatedAt
+        case accessBlocked
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+
+        do {
+            url = try container.decode(URL.self, forKey: .url)
+            fileId = try container.decode(Int.self, forKey: .fileId)
+            right = try container.decode(String.self, forKey: .right)
+
+            validUntil = try container.decodeIfPresent(TimeInterval.self, forKey: .validUntil)
+            capabilities = try container.decode(Rights.self, forKey: .capabilities)
+
+            createdBy = try container.decode(TimeInterval.self, forKey: .createdBy)
+            createdAt = try container.decode(TimeInterval.self, forKey: .createdAt)
+            updatedAt = try container.decode(TimeInterval.self, forKey: .updatedAt)
+
+            accessBlocked = try container.decode(Bool.self, forKey: .accessBlocked)
+        } catch {
+            // TODO: remove
+            fatalError("error:\(error)")
+        }
+    }
+}
+
 public class DriveApiFetcher: ApiFetcher {
     @LazyInjectService var accountManager: AccountManageable
     @LazyInjectService var tokenable: InfomaniakTokenable