You don't want to recreate this FocusNode every build, because you need to dispose of it, which (sadly) means you'd need to make this a stateful widget.

But... What's your goal here? Do you just want to know if a context doesn't have focus? If so, you could use something like this, and keep it stateless.

  return Focus(
    canRequestFocus: false,
    child: Builder(builder: (BuildContext context) {
      return NotificationListener<ScrollUpdateNotification>(
        child: scrollableResult,
        onNotification: (ScrollUpdateNotification notification) {
          final FocusNode node = Focus.of(context);
          if (notification.dragDetails != null && !node.hasFocus) {
            node.requestFocus();
          }
          return true;
        },
      );
    }),
  );

For the focus node, I'm using that to dismiss the keyboard when scrolling happens. I don't want to spam the Focus every time a scroll event happens so I keep a reference to the dismissNode to make sure that I only requestFocus once. It's fine if the FocusNode gets disposed, it's just a way to filter out duplicate events, if it never worked everything would still look the same.

Where are you disposing it?

I didn't realize we were talking about literally calling .dispose(). I'll rework it.

Started using unfocus instead so no FocusNode instance is needed.

We probably shouldn't return true here -eating scroll notifications this low in the tree is likely to break people further up who also want to know about scrolling.

Apple calls this behavior "none", I chose "manual".

Why do you need this to write this differently from focusScope.hasFocus? And if that's the case, then why wouldn't this work?:

if (notification.dragDetails != null) {
  focusScope.unfocus();
}

Basically, what's the reason for the extra conditions?

notifcation.dragDetails != null is to make sure the scrolling is the result of a drag, these events get fired too when the scrollview is scrolled as the result of a keyboard showing.

focusScope.focusedChild != null is because I'm going to read from the focusedChild and I don't want to read from a null pointer.

focusScope.focusedChild.hasFocus makes sure I don't spam focusScope.unfocus() and that it only gets called once for all the scrolling events that get sent.

Could I just use focusScole.hasFocus and avoid talking to the focusedChild?

I switched it over to focusScope.hasFocus. It wasn't like this because i found the other way to do it first and it worked.

Is there a reason you want to see if the scope is focused, rather than the nearest focus node? It's possible that this ScrollView isn't the focused child of the scope: if there's another child of the scope (i.e. a sibling of the ScrollView), and it's focused, then focusScope.hasFocus would return true, but children of this ScrollView wouldn't have focus.

If you expect the ScrollView to be enclosed in a Focus widget, you could use Focus.of(context).hasFocus. If you don't expect that (which is probably the case), you can introduce a focus node here (probably using a Focus widget with canRequestFocus set to false) and test to see if that has focus, which would mean that one of the children of the ScrollView has focus. You can keep the widget stateless by using a Builder to let you look up the node that the Focus introduces, as in my previous comment.

Here is what I would like to write:

if (Keyboard.isVisible) {
  Keyboard.hide();
}

If the scrollview has a sibling that is a TextField that is focused, we want this scrolling action to dismiss his keyboard too. (I think that is the case you are mentioning).

OK, in that case, then looking at the scope is appropriate.