add deeplink handle for ios

Author: Tlaster

iosApp/flare/Localizable.xcstrings

@@ -18270,6 +18270,26 @@
         }
       }
     },
+    "deep_link_account_picker_open_in_browser" : {
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Open in browser"
+          }
+        }
+      }
+    },
+    "deep_link_account_picker_title" : {
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Select account"
+          }
+        }
+      }
+    },
     "delete" : {
       "localizations" : {
         "af" : {

iosApp/flare/UI/Component/Backport.swift

@@ -10,6 +10,24 @@ extension Backport where Content: View {
             content.labelStyle(BackportLabelStyle(spacing: spacing))
         }
     }
+    
+    @ViewBuilder
+    func navigationSubtitle(_ subtitle: Text) -> some View {
+        if #available(iOS 26.0, *) {
+            content.navigationSubtitle(subtitle)
+        } else {
+            content
+        }
+    }
+    
+    @ViewBuilder
+    func navigationSubtitle<S>(_ subtitle: S) -> some View where S : StringProtocol {
+        if #available(iOS 26.0, *) {
+            content.navigationSubtitle(subtitle)
+        } else {
+            content
+        }
+    }
 }
 
 struct BackportLabelStyle: LabelStyle {

iosApp/flare/UI/Route/Route.swift

@@ -90,6 +90,8 @@ enum Route: Hashable, Identifiable {
             StatusMediaScreen(accountType: accountType, statusKey: statusKey, initialIndex: Int(selectedIndex), preview: preview)
         case .appLog:
             AppLogScreen()
+        case .deepLinkAccountPicker(let originalUrl, let data):
+            DeepLinkAccountPicker(originalUrl: originalUrl, data: data, onNavigate: onNavigate)
         default:
             Text("Not done yet for \(self)")
         }
@@ -133,6 +135,7 @@ enum Route: Hashable, Identifiable {
     case userFans(AccountType, MicroBlogKey)
     case dmConversation(AccountType, MicroBlogKey, String)
     case appLog
+    case deepLinkAccountPicker(String, [MicroBlogKey: Route])
 
     fileprivate static func fromCompose(_ compose: DeeplinkRoute.Compose) -> Route? {
         switch onEnum(of: compose) {
@@ -192,28 +195,37 @@ enum Route: Hashable, Identifiable {
 
     static func fromDeepLink(url: String) -> Route? {
         if let deeplinkRoute = DeeplinkRoute.companion.parse(url: url) {
-            switch onEnum(of: deeplinkRoute) {
-            case .compose(let compose):
-                return fromCompose(compose)
-            case .media(let media):
-                return fromMedia(media)
-            case .profile(let profile):
-                return fromProfile(profile)
-            case .rss(let rss):
-                switch onEnum(of: rss) {
-                case .detail(let data):
-                    return Route.rssDetail(data.url)
-                }
-            case .search(let search):
-                return Route.search(search.accountType, search.query)
-            case .status(let status):
-                return fromStatus(status)
-            case .login:
-                return Route.serviceSelect
-            }
+            return fromDeepLinkRoute(deeplinkRoute: deeplinkRoute)
         } else {
             return nil
         }
-
+    }
+    
+    static func fromDeepLinkRoute(deeplinkRoute: DeeplinkRoute) -> Route? {
+        switch onEnum(of: deeplinkRoute) {
+        case .compose(let compose):
+            return fromCompose(compose)
+        case .media(let media):
+            return fromMedia(media)
+        case .profile(let profile):
+            return fromProfile(profile)
+        case .rss(let rss):
+            switch onEnum(of: rss) {
+            case .detail(let data):
+                return Route.rssDetail(data.url)
+            }
+        case .search(let search):
+            return Route.search(search.accountType, search.query)
+        case .status(let status):
+            return fromStatus(status)
+        case .login:
+            return Route.serviceSelect
+        case .deepLinkAccountPicker(let picker):
+            return .deepLinkAccountPicker(picker.originalUrl, picker.data.mapValues { route in
+                return fromDeepLinkRoute(deeplinkRoute: route)
+            }.compactMapValues { $0 })
+        case .openLinkDirectly(_):
+            return nil
+        }
     }
 }

iosApp/flare/UI/Route/Router.swift

@@ -1,8 +1,10 @@
 import SwiftUI
 import KotlinSharedUI
 import LazyPager
+import Combine
 
 struct Router<Root: View>: View {
+    @Environment(\.openURL) private var openURL
     @ViewBuilder let root: (@escaping (Route) -> Void) -> Root
     @State private var backStack: [Route] = []
     @State private var sheet: Route? = nil
@@ -11,6 +13,22 @@ struct Router<Root: View>: View {
     @State private var showDeleteStatusAlert = false
     @State private var showMastodonReportStatusAlert = false
     @State private var mastodonReportStatusData: (AccountType, MicroBlogKey, MicroBlogKey?)? = nil
+    @StateObject private var deepLinkPresenter: KotlinPresenter<DeepLinkPresenterState>
+    @StateObject private var deepLinkHandler = DeepLinkHandler()
+    
+    init(@ViewBuilder root: @escaping (@escaping (Route) -> Void) -> Root) {
+        self.root = root
+        let handler = DeepLinkHandler()
+        self._deepLinkHandler = .init(wrappedValue: handler)
+        self._deepLinkPresenter = .init(wrappedValue: .init(presenter: DeepLinkPresenter(onRoute: { [weak handler] deeplinkRoute in
+            if let route = Route.fromDeepLinkRoute(deeplinkRoute: deeplinkRoute){
+                handler?.onRoute?(route)
+            }
+        }, onLink: { [weak handler] link in
+            handler?.onLink?(link)
+        })))
+    }
+    
     var body: some View {
         NavigationStack(path: $backStack) {
             root({ route in
@@ -58,13 +76,19 @@ struct Router<Root: View>: View {
             Text("mastodon_report_status_alert_message")
         }
         .environment(\.openURL, OpenURLAction { url in
-            if let newRoute = Route.fromDeepLink(url: url.absoluteString) {
-                navigate(route: newRoute)
-                return .handled
-            } else {
-                return .systemAction
-            }
+            deepLinkPresenter.state.handle(url: url.absoluteString)
+            return .handled
         })
+        .onAppear {
+            deepLinkHandler.onRoute = { route in
+                navigate(route: route)
+            }
+            deepLinkHandler.onLink = { link in
+                if let url = URL(string: link) {
+                    openURL(url)
+                }
+            }
+        }
     }
 
     func navigate(route: Route) {
@@ -87,7 +111,15 @@ struct Router<Root: View>: View {
 
     func isSheetRoute(route: Route) -> Bool {
         switch route {
-        case .composeNew, .composeQuote, .composeReply, .composeVVOReplyComment, .tabSettings, .statusBlueskyReport, .statusMisskeyReport, .statusAddReaction:
+        case .deepLinkAccountPicker,
+                .composeNew,
+                .composeQuote,
+                .composeReply,
+                .composeVVOReplyComment,
+                .tabSettings,
+                .statusBlueskyReport,
+                .statusMisskeyReport,
+                .statusAddReaction:
             return true
         default:
             return false
@@ -103,3 +135,8 @@ struct Router<Root: View>: View {
         }
     }
 }
+
+class DeepLinkHandler : ObservableObject {
+    var onRoute: ((Route) -> Void)?
+    var onLink: ((String) -> Void)?
+}

iosApp/flare/UI/Screen/DeepLinkAccountPicker.swift

@@ -0,0 +1,73 @@
+import SwiftUI
+import KotlinSharedUI
+import SwiftUIBackports
+
+struct DeepLinkAccountPicker: View {
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.openURL) private var openURL
+    let originalUrl: String
+    let data: [MicroBlogKey : Route]
+    let onNavigate: (Route) -> Void
+    
+    var body: some View {
+        List {
+            ForEach(data.keys.sorted(by: { $0.id < $1.id }), id: \.self) { userKey in
+                if let route = data[userKey] {
+                    Button {
+                        onNavigate(route)
+                        dismiss()
+                    } label: {
+                        UserItemView(userKey: userKey)
+                    }
+                }
+            }
+            Button {
+                openURL(URL(string: originalUrl)!)
+                dismiss()
+            } label: {
+                Label {
+                    Text("deep_link_account_picker_open_in_browser")
+                } icon: {
+                    Image(.faGlobe)
+                }
+
+            }
+        }
+        .navigationTitle("deep_link_account_picker_title")
+        .backport
+        .navigationSubtitle("deep_link_account_picker_subtitle")
+        .toolbar {
+            ToolbarItem(placement: .cancellationAction) {
+                Button(
+                    role: .cancel
+                ) {
+                    dismiss()
+                } label: {
+                    Label {
+                        Text("Cancel")
+                    } icon: {
+                        Image("fa-xmark")
+                    }
+                }
+            }
+        }
+    }
+}
+
+private struct UserItemView : View {
+    @StateObject private var presenter: KotlinPresenter<UserState>
+    
+    init(userKey: MicroBlogKey) {
+        self._presenter = .init(wrappedValue: .init(presenter: UserPresenter(accountType: AccountType.Specific(accountKey: userKey), userKey: nil)))
+    }
+    
+    var body: some View {
+        StateView(state: presenter.state.user) { user in
+            UserCompatView(data: user)
+        } errorContent: { error in
+            UserErrorView(error: error)
+        } loadingContent: {
+            UserLoadingView()
+        }
+    }
+}

shared/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/home/DeepLinkPresenter.kt

@@ -15,7 +15,9 @@ import io.ktor.http.URLProtocol
 import io.ktor.http.buildUrl
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toImmutableMap
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 
@@ -51,19 +53,25 @@ public class DeepLinkPresenter(
                 if (url.startsWith("$APPSCHEMA://")) {
                     DeeplinkRoute.parse(url)?.let {
                         if (it is DeeplinkRoute.OpenLinkDirectly) {
-                            onLink(it.url)
+                            withContext(Dispatchers.Main) {
+                                onLink(it.url)
+                            }
                         } else {
-                            onRoute(it)
+                            withContext(Dispatchers.Main) {
+                                onRoute(it)
+                            }
                         }
                     }
                     pendingUrl = null
                 } else {
                     patternFlow.collect { pattern ->
                         val matches = DeepLinkMapping.matches(url, pattern)
                         if (matches.isEmpty()) {
-                            onLink.invoke(url)
+                            withContext(Dispatchers.Main) {
+                                onLink.invoke(url)
+                            }
                         } else {
-                            onRoute.invoke(
+                            val route =
                                 DeeplinkRoute.DeepLinkAccountPicker(
                                     originalUrl =
                                         buildUrl {
@@ -77,8 +85,10 @@ public class DeepLinkPresenter(
                                                 it.key.accountKey to it.value.deepLink(it.key.accountKey)
                                             }.toMap()
                                             .toImmutableMap(),
-                                ),
-                            )
+                                )
+                            withContext(Dispatchers.Main) {
+                                onRoute.invoke(route)
+                            }
                         }
                         pendingUrl = null
                     }