Try making your view controller become first responder and stop it from resigning first responder

- (BOOL)canResignFirstResponder {

    return NO;

}



- (BOOL)canBecomeFirstResponder {

    return YES;

}

https://github.com/dwieringa/WKWebViewEditMenuHidingTest/pull/1

Based on your workaround, I found out that:

-(void)menuWillShow:(NSNotification *)notification

{

    NSLog(@"MENU WILL SHOW");



    dispatch_async(dispatch_get_main_queue(), ^{

        [[UIMenuController sharedMenuController] setMenuVisible:NO animated:NO];

    });



}

Will prevent the menu from flashing 90% of the times.. Still not good enough, but it's another workaround before we find a decent solution.

Hey guys after spending a hours on it, i found dirty solution with %100 success rate.

Logic is; detect when UIMenuController did shown and update it.

In your ViewController(containing WKWebView) add UIMenuControllerDidShowMenu observer in viewDidLoad() like this;

override func viewDidLoad() {

super.viewDidLoad()

       NotificationCenter.default.addObserver(

                         self,

                         selector: #selector(uiMenuViewControllerDidShowMenu),

                         name: NSNotification.Name.UIMenuControllerDidShowMenu,

                         object: nil)

}

Don't forget to remove observer in deinit.

    deinit {

    NotificationCenter.default.removeObserver(

                       self,

                       name: NSNotification.Name.UIMenuControllerDidShowMenu,

                       object: nil)

    }

And in your selector, update UIMenuController like this:

func uiMenuViewControllerDidShowMenu() {

        if longPress {

            let menuController = UIMenuController.shared

            menuController.setMenuVisible(false, animated: false)

            menuController.update() //You can only call this and it will still work as expected but i also call setMenuVisible just to make sure.

        }

    }

In your ViewController who ever calls the UIMenuController, this method will get called. I am developing browser app so i have also searchBar and user may want to paste text to there. Because of that i detect longPress in my webview and check if UIMenuController is summoned by WKWebView.

This solution will behave like in gif. You can see menu for a second but you can't tap it. You can try to tap it before it fades away but you won't succeed. Please try and tell me your results.

I hope it helps someone.

Cheers.

This bug is actually caused by the actions being added in the WKContentView, which is a private class. You could add a UIView extension to work around it like this:

import UIKit



extension UIView {



    open override class func initialize() {

        guard NSStringFromClass(self) == "WKContentView" else { return }



        swizzleMethod(#selector(canPerformAction), withSelector: #selector(swizzledCanPerformAction))

    }



    fileprivate class func swizzleMethod(_ selector: Selector, withSelector: Selector) {

        let originalSelector = class_getInstanceMethod(self, selector)

        let swizzledSelector = class_getInstanceMethod(self, withSelector)

        method_exchangeImplementations(originalSelector, swizzledSelector)

    }



    @objc fileprivate func swizzledCanPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {

        return false

    }

}

I Fixed it after some observation.

In -canPerformAction:withSender: I am returning NO for _share and _define options as I don't need them in my project. It works as expected on selection of word for first time, but shows up the options from second time.

Simple fix: Add [self becomeFirstResponder]; in tapGuesture or Touch delegate methods

-(BOOL)canPerformAction:(SEL)action withSender:(id)sender {

    SEL defineSEL = NSSelectorFromString(@"_define:");

    if(action == defineSEL){

        return NO;

    }



    SEL shareSEL = NSSelectorFromString(@"_share:");

    if(action == shareSEL){

        return NO;

    }

    return YES;

}



// Tap gesture delegate method

- (void)singleTap:(UITapGestureRecognizer *)sender {

    lastTouchPoint = [sender locationInView:self.webView];

    [self becomeFirstResponder]; //added this line to fix the issue//

}

Here's my final solution, adapted from the solutions posted here. The key is to listen for the UIMenuControllerWillShowMenu notification and then Dispatch.main.async to hide the menu. This seems to do the trick to avoid the flashing menu.

My example uses a UITextField, but it should be easily adapted to a WKWebView.

class NoMenuTextField: UITextField {



    override func didMoveToSuperview() {

        super.didMoveToSuperview()

        if superview == nil {

            deregisterForMenuNotifications()

        } else {

            registerForMenuNotifications()

        }

    }



    func registerForMenuNotifications() {

        NotificationCenter.default.addObserver(forName: Notification.Name.UIMenuControllerWillShowMenu,

                                               object: nil,

                                               queue: OperationQueue.main)

        { _ in

            DispatchQueue.main.async {

                UIMenuController.shared.setMenuVisible(false, animated: false)

                UIMenuController.shared.update()

            }

        }

    }



    func deregisterForMenuNotifications() {

        NotificationCenter.default.removeObserver(self,

                                                  name: Notification.Name.UIMenuControllerWillShowMenu,

                                                  object: nil)

    }

}

I tried the solution from Stephan Heilner but it didn't compile in Swift 4.

This is my implementation to disable the menuController in a WKWebView that works with Swift 4.

In my WKWebView subclass, I added these property and function :

var wkContentView: UIView? {

    return self.subviewWithClassName("WKContentView")

}





private func swizzleResponderChainAction() {

    wkContentView?.swizzlePerformAction()

}

Then, I added an extension in the same file, but out of the WKWebView subclass :

// MARK: - Extension used for the swizzling part linked to wkContentView (see above)

extension UIView {



    /// Find a subview corresponding to the className parameter, recursively.

    func subviewWithClassName(_ className: String) -> UIView? {



        if NSStringFromClass(type(of: self)) == className {

            return self

        } else {

            for subview in subviews {

                return subview.subviewWithClassName(className)

            }

        }

        return nil

    }



    func swizzlePerformAction() {

        swizzleMethod(#selector(canPerformAction), withSelector: #selector(swizzledCanPerformAction))

    }



    private func swizzleMethod(_ currentSelector: Selector, withSelector newSelector: Selector) {

        if let currentMethod = self.instanceMethod(for: currentSelector),

            let newMethod = self.instanceMethod(for:newSelector) {

            let newImplementation = method_getImplementation(newMethod)

            method_setImplementation(currentMethod, newImplementation)

        } else {

            print("Could not find originalSelector")

        }

    }



    private func instanceMethod(for selector: Selector) -> Method? {

        let classType = type(of: self)

        return class_getInstanceMethod(classType, selector)

    }



    @objc private func swizzledCanPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {

        return false

    }

}

And finally, I called the swizzleResponderChainAction() function from the initializer (you can either override the designated initializer, or create a convenience one):

override init(frame: CGRect, configuration: WKWebViewConfiguration) {

    super.init(frame: frame, configuration: configuration)



    swizzleResponderChainAction()

}

Now, the WKWebView does not crash anymore when using a UIMenuController.

One way that I've used is to simply disable the menu using CSS. The CSS property is called -webkit-touch-callout: none;. You can apply it to the top level element and disable it for the whole page or any child element and disable it with more precision. Hope that helps.

pragma mark - WKNavigationDelegate

- (void)webView:(WKWebView *)webView didFinishNavigation:(null_unspecified WKNavigation *)navigation {

    // Add:

    // Disable LongPress and Selection, no more UIMenucontroller

    [self.wkWebView evaluateJavaScript:@"document.documentElement.style.webkitUserSelect='none'" completionHandler:nil];

    [self.wkWebView evaluateJavaScript:@"document.documentElement.style.webkitTouchCallout='none'" completionHandler:nil]; }

In iOS 11, I have found a simple solution by an extension of WKWebView. I have not checked to see if this will work in earlier versions of iOS. The following is a simple example with one menu item.

import UIKit

import WebKit



extension WKWebView {



    override open func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {

        switch action {

        case #selector(highlightHandler):

            return true

        default:

            return false

        }

    }



    func createEditMenu() { // Should be called once

        let highlight = UIMenuItem(title: "Highlight", action: #selector(highlightHandler))

        menuItems.append(highlight)

        UIMenuController.shared.menuItems = [highlight]

    }



    @objc func highlightHandler(sender: UIMenuItem) {

        print("highlight clicked")

    }

}