SwiftUI detect when contextMenu is open

I've been testing this. Here's what I found out:

As you observed, this does not call a function:

.contextMenu {
   print("open")
}

Putting an EmptyView() in a contextMenu also does not trigger a function. Since EmptyView() is literally an empty view, it never gets rendered on the View. Since it never appears, onAppear can never get triggered:

.contextMenu {
    EmptyView()
    .onAppear {
        print("open")
    }
}

A Spacer() element will trigger a function, but it also leads to the contextMenu having an empty row item, which looks bad:

 .contextMenu {
    Spacer().onAppear {
       print("open")
    }
}

An empty Text element will trigger a function, but it once again leads to the contextMenu having an empty row item, which looks bad (same as above picture):

 .contextMenu {
    Text("").onAppear {
       print("open")
    }
}

As someone else pointed out, adding a simultaneousGesture will break scrolling:

.simultaneousGesture(LongPressGesture(minimumDuration: 0.5).onEnded { _ in
        print("Opened")
    })

The best solution?

Just put .onAppear on the first already-existing element in the contextMenu

.onAppear {
        print("open")
    }

Don't create a new element (EmptyView(), Spacer(), Text(""), etc)

The previously mentioned solutions have some issues, namely onAppear is only called the first time the menu appears (and not for additional appearances) and onDisappear won't be called (it seems like the menu items are cached internally).

Here is a drop in solution:

import SwiftUI

extension View {
  
  /// A context menu with callbacks for onAppear and onDisappear
  func contextMenu(
    actions: [UIAction],
    onAppear: @escaping () -> Void,
    onDisappear: @escaping () -> Void
  ) -> some View {
    modifier(ContextMenuViewModifier(actions: actions, onAppear: onAppear, onDisappear: onDisappear))
  }
}

private struct ContextMenuViewModifier: ViewModifier {
  let actions: [UIAction]
  let onAppear: () -> Void
  let onDisappear: () -> Void
  
  func body(content: Content) -> some View {
    InteractiveView(content: { content }, actions: actions, onAppear: onAppear, onDisappear: onDisappear)
  }
}

private struct InteractiveView<Content: View>: UIViewRepresentable {
  typealias UIViewControllerType = UIView
  
  @ViewBuilder var content: Content
  
  let actions: [UIAction]
  let onAppear: () -> Void
  let onDisappear: () -> Void
  
  func makeCoordinator() -> Coordinator {
    return Coordinator(parent: self)
  }
  
  func makeUIView(context: Context) -> some UIView {
    let hostedView = UIHostingController(rootView: content)
    hostedView.view.backgroundColor = .clear
    hostedView.view.translatesAutoresizingMaskIntoConstraints = false
    
    context.coordinator.contextMenu = UIContextMenuInteraction(delegate: context.coordinator)
    hostedView.view.addInteraction(context.coordinator.contextMenu!)
    
    return hostedView.view
  }
  
  func updateUIView(_ uiView: UIViewType, context: Context) {
    //
  }
  
  class Coordinator: NSObject, UIContextMenuInteractionDelegate {
    var contextMenu: UIContextMenuInteraction!
    
    private let parent: InteractiveView
    
    init(parent: InteractiveView) {
      self.parent = parent
    }
    
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration? {
      UIContextMenuConfiguration(identifier: nil, previewProvider: nil, actionProvider: { [self] suggestedActions in
        return UIMenu(title: "", children: parent.actions)
      })
    }
    
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration) -> UITargetedPreview? {
      let parameters = UIPreviewParameters()
      parameters.backgroundColor = .clear
      return UITargetedPreview(view: interaction.view!, parameters: parameters)
    }
    
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, willDisplayMenuFor configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionAnimating?) {
      parent.onAppear()
    }
    
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, willEndFor configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionAnimating?) {
      parent.onDisappear()
    }
  }
}

You can use it like so:

view
  .contextMenu(
    actions: [
      UIAction(title: "Button") { action in
        // Your code here
      }
    ],
    onAppear: {
      print("Menu onAppear")
    },
    onDisappear: {
      print("Menu onDisappear")
    }
  )