Intercept request with WKWebView

Question

Now i\'m using UIWebView and with canInitWithRequest: of NSURLProtocol i can intercept all requests and do with it what I want.

In

Answer 1

I know I am late but I am able to solve this problem. I can intercept each and every request even your http/https call using below trick. I can also trace the call made from html to server calls. I can also use this to render html with offline content.

1. Download the html of the website that we want to render in offline or online to intercept the request.
2. Either place the html in document directory of the user or place it inside the archive. But we should know the path of the html file.
3. Place all your js, cs, woff, font of our website at the same level as our base html. We need to given permission while loading the web view.
4. Then we have to register our own custom handler scheme with WKWebView. When wkwebview see the pattern "myhandler-webview" then it will give you control and you will get the callback to 'func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask)' delegate implementation. You can play around with url in this delegate like mentioned in point 6.

      let configuration = WKWebViewConfiguration();
        configuration.setURLSchemeHandler(self, forURLScheme: "myhandler-webview");
        webView = WKWebView(frame: view.bounds, configuration: configuration);

5. Convert file scheme to the custom scheme (myhandler-webview) then load it with WKWebView

    let htmlPath = Bundle.main.path(forResource: "index", ofType: "html")
    var htmlURL = URL(fileURLWithPath: htmlPath!, isDirectory: false)                    
    htmlURL = self.changeURLScheme(newScheme: "myhandler-webview", forURL: htmlURL)
    self.webView.load(URLRequest(url: htmlURL))

6. Implement below methods of WKURLSchemeHandler protocol and handle didReceiveResponse, didReceiveData, didFinish delegate methods of WKURLSchemeTask.

    func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
        print("Function: \(#function), line: \(#line)")
        print("==> \(urlSchemeTask.request.url?.absoluteString ?? "")\n")

    // You can find the url pattern by using urlSchemeTask.request.url. and create NSData from your local resource and send the data using 3 delegate method like done below.
    // You can also call server api from this native code and return the data to the task.
    // You can also cache the data coming from server and use it during offline access of this html.
    // When you are returning html the the mime type should be 'text/html'. When you are trying to return Json data then we should change the mime type to 'application/json'.
    // For returning json data you need to return NSHTTPURLResponse which has base classs of NSURLResponse with status code 200. 

    // Handle WKURLSchemeTask delegate methods
        let url = changeURLScheme(newScheme: "file", forURL: urlSchemeTask.request.url!)

        do {
            let data = try Data(contentsOf: url)

            urlSchemeTask.didReceive(URLResponse(url: urlSchemeTask.request.url!, mimeType: "text/html", expectedContentLength: data.count, textEncodingName: nil))
            urlSchemeTask.didReceive(data)
            urlSchemeTask.didFinish()
        } catch {
            print("Unexpected error when get data from URL: \(url)")
        }
    }

    func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
        print("Function: \(#function), line: \(#line)")
        print("==> \(urlSchemeTask.request.url?.absoluteString ?? "")\n")
    }

Let me know if this explanation is not enough.

Objective c example mentioned below

intercepting request with wkwebview

Answer 2

in iOS 11 WKWebView has come up with Custom Scheme Handler called WKURLSchemeHandler, which you can use to intercept the custom events. for more info check out this project. https://github.com/BKRApps/KRWebView

Answer 3

You can intercept requests on WKWebView since iOS 8.0 by implementing the decidePolicyFor: navigationAction: method for the WKNavigationDelegate

 func webView(_ webView: WKWebView, decidePolicyFor 
       navigationAction: WKNavigationAction, 
       decisionHandler: @escaping (WKNavigationActionPolicy) -> Swift.Void) {

    //link to intercept www.example.com

    // navigation types: linkActivated, formSubmitted, 
    //                   backForward, reload, formResubmitted, other

    if navigationAction.navigationType == .linkActivated {
        if navigationAction.request.url!.absoluteString == "http://www.example.com" {
            //do stuff

            //this tells the webview to cancel the request
            decisionHandler(.cancel)
            return
        }
    }

    //this tells the webview to allow the request
    decisionHandler(.allow)

}

Answer 4

One can use WKURLSchemeHandler to intercept each and every request to be loaded in WKWebView, Only disadvantage is that you cannot register http or https scheme for interception,

Solution over that is, Replace your http/https scheme of url with custom scheme url like xyz:// for e.g. https://google.com can be loaded like xyz://google.com Now you will get a callback in WKURLSchemeHandler there you again replace it back to https and load data programmatically and call urlSchemeTask.didReceive(response)

This way each and every https request will come to your handler.

Answer 5

I am blindly taking guesses since I only have my windows computer with me. By reading the Apple Developer documentation here is information I gathered that might lead to some ideas on how to solve the question.

Based on WKWebView,

Set the delegate property to an object conforming to the WKUIDelegate protocol to track the loading of web content.

Also, I see we can set our navigationDelegate with the,

weak var navigationDelegate: WKNavigationDelegate? { get set }

The methods of the WKNavigationDelegate protocol help you implement custom behaviors that are triggered during a web view's process of accepting, loading, and completing a navigation request.

Then after we create and set our custom WKNavigationDelegate, we would override some methods to intercept something we might be looking for. I found the Responding to Server Actions section of some interest since they receive a WKNavigation as parameter. Moreover, you might want to skim through WKNavigationAction and WKNavigationResponse see if there is perhaps something which might help us achieve our goal.

BTW, I am just giving some ideas on what to try so that we can solve this question, ideas which might be 100% wrong cause I have not tried them myself.

Answer 6

there are many ways to implement intercepter request.

1. setup a local proxy, use WKNavigationDelegate

   -[ViewController webView:decidePolicyForNavigationAction:decisionHandler:]
   

   load new request and forward to local server, and at the local server side you can do something(eg. cache).

2. private api. use WKBrowsingContextController and custom URLProtocol

   Class cls = NSClassFromString(@"WKBrowsingContextController");
   SEL sel = NSSelectorFromString(@"registerSchemeForCustomProtocol:");
   if ([(id)cls respondsToSelector:sel]) {
       // 把 http 和 https 请求交给 NSURLProtocol 处理
       [(id)cls performSelector:sel withObject:@"http"];
       [(id)cls performSelector:sel withObject:@"https"];
   }
   

3. use KVO to get system http/https handler.(ios 11, *)

   WKWebViewConfiguration *configuration = [[WKWebViewConfiguration alloc] init];
   URLSchemeHandler *schemeHandler = [[URLSchemeHandler alloc] init];
   [configuration setURLSchemeHandler:schemeHandler forURLScheme:@"test"];
   NSMutableDictionary *handlers = [configuration valueForKey:@"_urlSchemeHandlers"];
   handlers[@"http"] = schemeHandler;
   handlers[@"https"] = schemeHandler;
   

   all the three ways you probably need handle CORS & post bodies to be stripped,you overwrite change browser`s option request( Preflighted_requests),you can custom http header to replace http body for post bodies to be stripped.