Fix default browser selection

Telegram-iOS/Info.plist

@@ -264,6 +264,7 @@
 		<string>dgis</string>
 		<string>microsoft-edge-http</string>
 		<string>microsoft-edge-https</string>
+		<string>brave</string>
 	</array>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>

submodules/OpenInExternalAppUI/Sources/OpenInOptions.swift

@@ -12,7 +12,7 @@ public enum OpenInItem {
     case location(location: TelegramMediaMap, withDirections: Bool)
 }
 
-public enum OpenInApplication {
+public enum OpenInApplication: Equatable {
     case safari
     case maps
     case other(title: String, identifier: Int64, scheme: String, store: String?)
@@ -131,7 +131,14 @@ private func allOpenInOptions(context: AccountContext, item: OpenInItem) -> [Ope
             options.append(OpenInOption(identifier: "duckDuckGo", application: .other(title: "DuckDuckGo", identifier: 663592361, scheme: "ddgQuickLink", store: nil), action: {
                 return .openUrl(url: "ddgQuickLink://\(url)")
             }))
-        
+
+            options.append(OpenInOption(identifier: "brave", application: .other(title: "Brave", identifier: 1052879175, scheme: "brave", store: nil), action: {
+                if let escapedUrl = url.addingPercentEncoding(withAllowedCharacters: .urlQueryValueAllowed) {
+                    return .openUrl(url: "brave://open-url?url=\(escapedUrl)")
+                }
+                return .none
+            }))
+            
             options.append(OpenInOption(identifier: "alook", application: .other(title: "Alook Browser", identifier: 1261944766, scheme: "alook", store: nil), action: {
                 return .openUrl(url: "alook://\(url)")
             }))

submodules/PhotoResources/Sources/PhotoResources.swift

@@ -2953,15 +2953,17 @@ private func openInAppIconData(postbox: Postbox, appIcon: MediaResource) -> Sign
 
 private func drawOpenInAppIconBorder(into c: CGContext, arguments: TransformImageArguments) {
     c.setBlendMode(.normal)
-    c.setStrokeColor(UIColor(rgb: 0xeeeeee).cgColor)
-    c.setLineWidth(1.0)
+    c.setStrokeColor(UIColor(rgb: 0xe5e5e5).cgColor)
+    
+    let lineWidth: CGFloat = arguments.drawingRect.size.width < 30.0 ? 1.0 - UIScreenPixel : 1.0
+    c.setLineWidth(lineWidth)
     
     var radius: CGFloat = 0.0
     if case let .Corner(cornerRadius) = arguments.corners.topLeft, cornerRadius > CGFloat.ulpOfOne {
         radius = max(0, cornerRadius - 0.5)
     }
     
-    let rect = arguments.drawingRect.insetBy(dx: 0.5, dy: 0.5)
+    let rect = arguments.drawingRect.insetBy(dx: lineWidth / 2.0, dy: lineWidth / 2.0)
     c.move(to: CGPoint(x: rect.minX, y: rect.midY))
     c.addArc(tangent1End: CGPoint(x: rect.minX, y: rect.minY), tangent2End: CGPoint(x: rect.midX, y: rect.minY), radius: radius)
     c.addArc(tangent1End: CGPoint(x: rect.maxX, y: rect.minY), tangent2End: CGPoint(x: rect.maxX, y: rect.midY), radius: radius)

submodules/SettingsUI/Sources/Data and Storage/WebBrowserItem.swift

@@ -0,0 +1,309 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PhotoResources
+import OpenInExternalAppUI
+
+public class WebBrowserItem: ListViewItem, ItemListItem {
+    let account: Account
+    let theme: PresentationTheme
+    let title: String
+    let application: OpenInApplication
+    let checked: Bool
+    public let sectionId: ItemListSectionId
+    let action: () -> Void
+    
+    public init(account: Account, theme: PresentationTheme, title: String, application: OpenInApplication, checked: Bool, sectionId: ItemListSectionId, action: @escaping () -> Void) {
+        self.account = account
+        self.theme = theme
+        self.title = title
+        self.application = application
+        self.checked = checked
+        self.sectionId = sectionId
+        self.action = action
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = WebBrowserItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? WebBrowserItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+private let titleFont = Font.regular(17.0)
+
+public class WebBrowserItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private let iconNode: TransformImageNode
+    private let checkIconNode: ASImageNode
+    private let titleNode: TextNode
+    
+    private var item: WebBrowserItem?
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        
+        self.checkIconNode = ASImageNode()
+        self.checkIconNode.isLayerBacked = true
+        self.checkIconNode.displayWithoutProcessing = true
+        self.checkIconNode.displaysAsynchronously = false
+        
+        self.iconNode = TransformImageNode()
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.iconNode)
+        self.addSubnode(self.checkIconNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.activateArea)
+        
+        self.activateArea.activate = { [weak self] in
+            self?.item?.action()
+            return true
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: WebBrowserItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeIconLayout = self.iconNode.asyncLayout()
+        
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var leftInset: CGFloat = params.leftInset + 16.0 + 43.0
+            
+            let iconSize = CGSize(width: 29.0, height: 29.0)
+            let arguments = TransformImageArguments(corners: ImageCorners(radius: 5.0), imageSize: iconSize, boundingSize: iconSize, intrinsicInsets: UIEdgeInsets(), emptyColor: item.theme.list.mediaPlaceholderColor)
+            let imageApply = makeIconLayout(arguments)
+            
+            var updatedIconSignal: Signal<(TransformImageArguments) -> DrawingContext?, NoError>?
+            if currentItem?.application != item.application {
+                switch item.application {
+                case .safari:
+                    if let image = UIImage(bundleImageName: "Open In/Safari") {
+                        updatedIconSignal = openInAppIcon(postbox: item.account.postbox, appIcon: .image(image: image))
+                    }
+                case .maps:
+                    if let image = UIImage(bundleImageName: "Open In/Maps") {
+                        updatedIconSignal = openInAppIcon(postbox: item.account.postbox, appIcon: .image(image: image))
+                    }
+                case let .other(_, identifier, _, store):
+                    updatedIconSignal = openInAppIcon(postbox: item.account.postbox, appIcon: .resource(resource: OpenInAppIconResource(appStoreId: identifier, store: store)))
+                }
+            }
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 20.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let separatorHeight = UIScreenPixel
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors)
+            let contentSize = CGSize(width: params.width, height: 44.0)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            var updateCheckImage: UIImage?
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+            }
+            
+            if currentItem?.theme !== item.theme {
+                updateCheckImage = PresentationResourcesItemList.checkIconImage(item.theme)
+            }
+
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    strongSelf.activateArea.accessibilityLabel = item.title
+                    if item.checked {
+                        strongSelf.activateArea.accessibilityValue = "Selected"
+                    } else {
+                        strongSelf.activateArea.accessibilityValue = ""
+                    }
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    
+                    if let updateCheckImage = updateCheckImage {
+                        strongSelf.checkIconNode.image = updateCheckImage
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = imageApply()
+                    if let updatedImageSignal = updatedIconSignal {
+                        strongSelf.iconNode.setSignal(updatedImageSignal)
+                    }
+                    
+                    strongSelf.iconNode.frame = CGRect(origin: CGPoint(x: params.leftInset + floor((leftInset - params.leftInset - iconSize.width) / 2.0), y: floor((layout.contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    
+                    if let image = strongSelf.checkIconNode.image {
+                        strongSelf.checkIconNode.frame = CGRect(origin: CGPoint(x: params.width - params.rightInset - image.size.width - floor((44.0 - image.size.width) / 2.0), y: floor((contentSize.height - image.size.height) / 2.0)), size: image.size)
+                    }
+                    strongSelf.checkIconNode.isHidden = !item.checked
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    switch neighbors.bottom {
+                        case .sameSection(false):
+                            bottomStripeInset = leftInset
+                        default:
+                            bottomStripeInset = 0.0
+                            hasBottomCorners = true
+                            strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: leftInset, y: 11.0), size: titleLayout.size)
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: 44.0 + UIScreenPixel + UIScreenPixel))
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                    })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/WebBrowserSettingsController.swift

@@ -11,9 +11,11 @@ import AccountContext
 import OpenInExternalAppUI
 
 private final class WebBrowserSettingsControllerArguments {
+    let context: AccountContext
     let updateDefaultBrowser: (String?) -> Void
     
-    init(updateDefaultBrowser: @escaping (String?) -> Void) {
+    init(context: AccountContext, updateDefaultBrowser: @escaping (String?) -> Void) {
+        self.context = context
         self.updateDefaultBrowser = updateDefaultBrowser
     }
 }
@@ -24,7 +26,7 @@ private enum WebBrowserSettingsSection: Int32 {
 
 private enum WebBrowserSettingsControllerEntry: ItemListNodeEntry {
     case browserHeader(PresentationTheme, String)
-    case browser(PresentationTheme, String, String?, Bool, Int32)
+    case browser(PresentationTheme, String, OpenInApplication, String?, Bool, Int32)
     
     var section: ItemListSectionId {
         switch self {
@@ -37,7 +39,7 @@ private enum WebBrowserSettingsControllerEntry: ItemListNodeEntry {
         switch self {
             case .browserHeader:
                 return 0
-            case let .browser(_, _, _, _, index):
+            case let .browser(_, _, _, _, _, index):
                 return 1 + index
         }
     }
@@ -50,8 +52,8 @@ private enum WebBrowserSettingsControllerEntry: ItemListNodeEntry {
                 } else {
                     return false
                 }
-            case let .browser(lhsTheme, lhsTitle, lhsIdentifier, lhsSelected, lhsIndex):
-                if case let .browser(rhsTheme, rhsTitle, rhsIdentifier, rhsSelected, rhsIndex) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsIdentifier == rhsIdentifier, lhsSelected == rhsSelected, lhsIndex == rhsIndex {
+            case let .browser(lhsTheme, lhsTitle, lhsApplication, lhsIdentifier, lhsSelected, lhsIndex):
+                if case let .browser(rhsTheme, rhsTitle, rhsApplication, rhsIdentifier, rhsSelected, rhsIndex) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsApplication == rhsApplication, lhsIdentifier == rhsIdentifier, lhsSelected == rhsSelected, lhsIndex == rhsIndex {
                     return true
                 } else {
                     return false
@@ -68,8 +70,8 @@ private enum WebBrowserSettingsControllerEntry: ItemListNodeEntry {
         switch self {
             case let .browserHeader(theme, text):
                 return ItemListSectionHeaderItem(theme: theme, text: text, sectionId: self.section)
-            case let .browser(theme, title, identifier, selected, _):
-                return ItemListCheckboxItem(theme: theme, title: title, style: .right, checked: selected, zeroSeparatorInsets: false, sectionId: self.section) {
+            case let .browser(theme, title, application, identifier, selected, _):
+                return WebBrowserItem(account: arguments.context.account, theme: theme, title: title, application: application, checked: selected, sectionId: self.section) {
                     arguments.updateDefaultBrowser(identifier)
                 }
         }
@@ -82,11 +84,11 @@ private func webBrowserSettingsControllerEntries(context: AccountContext, presen
     let options = availableOpenInOptions(context: context, item: .url(url: "http://telegram.org"))
     
     entries.append(.browserHeader(presentationData.theme, presentationData.strings.WebBrowser_DefaultBrowser))
-    entries.append(.browser(presentationData.theme, presentationData.strings.WebBrowser_InAppSafari, nil, selectedBrowser == nil, 0))
+    entries.append(.browser(presentationData.theme, presentationData.strings.WebBrowser_InAppSafari, .safari, nil, selectedBrowser == nil, 0))
     
     var index: Int32 = 1
     for option in options {
-        entries.append(.browser(presentationData.theme, option.title, option.identifier, option.identifier == selectedBrowser, index))
+        entries.append(.browser(presentationData.theme, option.title, option.application, option.identifier, option.identifier == selectedBrowser, index))
         index += 1
     }
     
@@ -98,7 +100,7 @@ public func webBrowserSettingsController(context: AccountContext) -> ViewControl
     var presentControllerImpl: ((ViewController) -> Void)?
     
     let updateDisposable = MetaDisposable()
-    let arguments = WebBrowserSettingsControllerArguments(updateDefaultBrowser: { identifier in
+    let arguments = WebBrowserSettingsControllerArguments(context: context, updateDefaultBrowser: { identifier in
         let _ = updateWebBrowserSettingsInteractively(accountManager: context.sharedContext.accountManager, { $0.withUpdatedDefaultWebBrowser(identifier) }).start()
     })
     

submodules/TelegramUI/TelegramUI/OpenUrl.swift

@@ -644,20 +644,46 @@ func openExternalUrlImpl(context: AccountContext, urlContext: OpenURLContext, ur
             if parsedUrl.host == "t.me" || parsedUrl.host == "telegram.me" {
                 handleInternalUrl(parsedUrl.absoluteString)
             } else {
-                if #available(iOSApplicationExtension 9.0, iOS 9.0, *) {
-                    if let window = navigationController?.view.window {
-                        let controller = SFSafariViewController(url: parsedUrl)
-                        if #available(iOSApplicationExtension 10.0, iOS 10.0, *) {
-                            controller.preferredBarTintColor = presentationData.theme.rootController.navigationBar.backgroundColor
-                            controller.preferredControlTintColor = presentationData.theme.rootController.navigationBar.accentTextColor
+                let settings = context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.webBrowserSettings])
+                |> take(1)
+                |> map { sharedData -> WebBrowserSettings in
+                     if let current = sharedData.entries[ApplicationSpecificSharedDataKeys.webBrowserSettings] as? WebBrowserSettings {
+                         return current
+                     } else {
+                         return WebBrowserSettings.defaultSettings
+                     }
+                 }
+
+                let _ = (settings
+                |> deliverOnMainQueue).start(next: { settings in
+                    if settings.defaultWebBrowser == nil {
+                        if #available(iOSApplicationExtension 9.0, iOS 9.0, *) {
+                            if let window = navigationController?.view.window {
+                                let controller = SFSafariViewController(url: parsedUrl)
+                                if #available(iOSApplicationExtension 10.0, iOS 10.0, *) {
+                                    controller.preferredBarTintColor = presentationData.theme.rootController.navigationBar.backgroundColor
+                                    controller.preferredControlTintColor = presentationData.theme.rootController.navigationBar.accentTextColor
+                                }
+                                window.rootViewController?.present(controller, animated: true)
+                            } else {
+                                context.sharedContext.applicationBindings.openUrl(parsedUrl.absoluteString)
+                            }
+                        } else {
+                            context.sharedContext.applicationBindings.openUrl(url)
                         }
-                        window.rootViewController?.present(controller, animated: true)
                     } else {
-                        context.sharedContext.applicationBindings.openUrl(parsedUrl.absoluteString)
+                        let openInOptions = availableOpenInOptions(context: context, item: .url(url: url))
+                        if let option = openInOptions.first(where: { $0.identifier == settings.defaultWebBrowser }) {
+                            if case let .openUrl(url) = option.action() {
+                                context.sharedContext.applicationBindings.openUrl(url)
+                            } else {
+                                context.sharedContext.applicationBindings.openUrl(url)
+                            }
+                        } else {
+                            context.sharedContext.applicationBindings.openUrl(url)
+                        }
                     }
-                } else {
-                    context.sharedContext.applicationBindings.openUrl(url)
-                }
+                })
             }
         } else {
             context.sharedContext.applicationBindings.openUrl(url)