From my understanding and trying out some code, we can only monitor page navigation requests using
func webView(_ webView: WKWebView, decidePolicyFor navigationResponse: WKNavigationResponse, decisionHandler: #escaping (WKNavigationResponsePolicy) -> Void)
{
if // some condition
{
decisionHandler(.allow) // to allow the page navigation.
}
else
{
decisionHandler(.cancel) // to cancel the page navigation.
}
}
But is there any way to monitor and block some ajax requests in WKWebView?
And also to capture the ajax response.
Related
For example, I write as follows, then it works correctly, that is, the content that comes is displayed as it should and when the user clicks the link, it doesn't redirect anywhere.
extension AuthorizationContentView: WKNavigationDelegate {
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
if navigationAction.navigationType == .linkActivated {
decisionHandler(.cancel)
} else {
decisionHandler(.allow)
}
}
}
BUT I need to cover all the cases of clicking on the link and not just linkActivated(A link with an href attribute was activated by the user), but if I write just decisionHandler(.cancel), then the content is not displayed and it is unclear why so.
extension AuthorizationContentView: WKNavigationDelegate {
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
decisionHandler(.cancel)
return
}
}
UPD:
func setupWebView(content: String) {
let supportDarkCSS = "<style>:root { color-scheme: light dark; }</style>"
contentStackView.removeAllArrangedSubviews()
webView.loadHTMLString(content + supportDarkCSS, baseURL: nil)
contentStackView.addArrangedSubview(webView)
}
Ok, so after I understand what you are trying to do, the .linkActivated navigation type does not include all of the cases you are trying to block.
I think the best options is to keep intercept the requests using the func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) delegate function.
You can use the URLRequest property on the WKNavigationActioni.e navigationAction.request.
Then you can use the URLRequest metadata, for example, the URL itself (navigationAction.request.url) or the HTTP method, and understand if that request needs to be blocked.
I am looking for a way to disable a user interacting with links and images in SwiftUI using WKWebView. I have tried various ways but none have worked, and I have seen and tried the following post but nothing worked:
WKWebview allowsLinkPreview to false breaks text selection
WKWebview: Disable interaction and clicks on links
I am displaying a website that I have permission to display but due to its abnormal HTML structure it makes it hard to display the context, so I decided to try disabling user interactions with links. I do still want user interactions enabled so the user can scroll through the calendar presented to them, but not be able to click on links. If you have any suggestion I am open to them.
Here is my code:
struct CalanderWeb : UIViewRepresentable {
#State var request: URLRequest
func makeUIView(context: Context) -> WKWebView {
return WKWebView()
}
func updateUIView(_ uiView: WKWebView, context: Context) {
uiView.scrollView.isScrollEnabled = true
uiView.isOpaque = false
uiView.allowsBackForwardNavigationGestures = false
uiView.load(request)
}
func makeCoordinator() -> CalanderWeb.Coordinator {
Coordinator(self)
}
class Coordinator: NSObject, WKNavigationDelegate {
let parent: CalanderWeb
init(_ parent: CalanderWeb) {
self.parent = parent
}
func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
}
func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
}
func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
}
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
decisionHandler(.cancel)
}
}
}
Thank You.
Here is correct delegate callback
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
if navigationAction.navigationType == .linkActivated {
decisionHandler(.cancel)
} else {
decisionHandler(.allow)
}
}
depending of used HTML, probably also might be disabled .formSubmitted, if needed.
You'll have to override the method decidePolicyForNavigationAction in WKNavigationDelegate and provide .cancel in the completion block parameter decisionHandler. Here is the sample code:
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
decisionHandler(.cancel)
}
I have posted the delegate method I used if there is no event for button action how can I add that event with javascript .how can I use the functionalists in my view controller.
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
print(#function)
guard let url = navigationAction.request.url else {
decisionHandler(.allow)
return
}
if url.absoluteString.contains("ios-development-course") {
// this means login successful
decisionHandler(.cancel)
}
else {
decisionHandler(.allow)
}
}
When you click a button which is basically a link in web view, the navigation happens in web view.
There is a delegate method you can use to allow or cancel that navigation.
public func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
var shouldLoad = true
if navigationAction.navigationType == .linkActivated.
//user clicked button on web view
decisionHandler(shouldLoad ? .allow : .cancel)
}
}
I have a WKWebView in my application, there are some buttons inside the WKWebView on clicking on it, a new page is not loaded. By the look of it, they are trying to open an about_blank page. In the browser, the link is opening in a new page and the URL is loaded.
The way that you do this is by implementing WKUIDelegate and override this method
func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView?
If you return a new WKWebView with the passed configuration, the request will be loaded to a new webview. Since target=_blank tries to open a new window in browser, this method compensates for that in iOS. You could launch a new UIViewController with this new WKWebView where the request for target=_blank page.
Here is a simple example, where I substitute the main WKWebView with new webView, and load the request in same viewcontroller,
extension ViewController: WKNavigationDelegate, WKUIDelegate {
public func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
let newWebView = WKWebView(frame: self.webView.frame,
configuration: configuration)
view.addSubview(newWebView)
return newWebView
}
}
This in someway works like a tab in browser. But, bear in mind that with the change as above, forward and backward do not work, since you have created a new webview. If you want everything to work, I suggest that you load a new viewcontroller with this webview or create a new view where this would be loaded and shown, and you could switch to other main webview.
I went with this approach, even though this approach opens the URL in a device safari browser, anyway those links are pointing to external links, this method helped
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
if navigationAction.targetFrame == nil {
if let url = navigationAction.request.url {
let app = UIApplication.shared
if app.canOpenURL(url) {
app.open(url, options: [:], completionHandler: nil)
}
}
}
decisionHandler(.allow)
}
Swift Solution
public func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
if navigationAction.targetFrame == nil {
self.webView.load(navigationAction.request)
}
return nil
}
You need to delegate WKUIDelegate
In a WKWebView, every time I tap on a URL, the navigationType is .other. When does navigationType equal .linkActivated?
Very unlikely. Maybe you are interpreting the raw values wrong?
func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: #escaping (WKNavigationActionPolicy) -> Void) {
print(navigationAction.navigationType.rawValue)
// -1 "other" seen when assigning the url programatically
// 0 "linkActivated" a link with an href attribute was tapped
// 3 "reload" page was refreshed
}
See the docs where you can click on the enumerations listed and and see their raw values