This indirection doesn't seem to add too much value.. maybe just leave _handleSemanticsAction public and let RenderingBinding to handle raw args directly?

I do believe it is the responsibility of the semantics layer to decode args as it is the one that picks the messageCodec. If we were to decide that we need to change the message codec used, we should do the change in one place here instead of fixing up client code elsewhere.

Furthermore, the SemanticsActionEvent gives us a little more flexibility in the future to extend the information associated with a SemanticsEvent without breaking the method signature. For example, we may want to add the view ID from where the event was originating in the future.

Why not just mark this mustCallSuper?

My thinking was that this setup guarantees that accessibilityFeatures is called before handleAccessibilityFeaturesChanged is invoked on subclasses. With mustCallSuper you could accidentally call super at the end of your method and operate on outdated data.

But we don't do it this way for other handlers on the bindings, so I will change this to your suggestion as well.

What is the use case to expose this API?

Rephrasing from the PR description:

Clients can use ensureSemantics to turn on semantics globally for the entire app. Previously, this was all handled internally by the PipelineOwner. However, in the multi view world we will have multiple PipelineOwners (one to power each view), so a single source of truth to turn on semantics for of all these PipelineOwners across the entire app is needed.

It is weird that we reuse the same interface for handles from two different object. Do you know why we need to add an ensureSemantics to the SemanticsBinding?
or PipelineOwner can do the logic in the construction and put dispose logic to one callback and reuse the SemanticsHandle class directly?

Do you know why we need to add an ensureSemantics to the SemanticsBinding?

See answer to previous question.

or PipelineOwner can do the logic in the construction and put dispose logic to one callback and reuse the SemanticsHandle class directly?

Can you elaborate what you mean by this?

This is mostly here for backwards compatibility. PipelineOwner had an ensureSemantics method that is getting some good use, I didn't want to remove it just yet. But like I said in the other comment, we also need something that manages the state of semantics on/off globally outside of individual PipelineOwners.

It is weird that we reuse the same interface for handles from two different object.

The objects have the same purpose, though. They are both handles to denote your interest in semantics. One on a global level, the other on a per-PipelineOwner level.

Thanks for explanation, yes this make sense.

What i meant to reuse the SemanticsHandle class is to do something like this

  SemanticsHandle ensureSemantics({ VoidCallback? listener }) {
    _outstandingSemanticsHandles += 1;
    if (_outstandingSemanticsHandles == 1) {
      assert(_semanticsOwner == null);
      assert(onSemanticsUpdate != null, 'Attempted to open a semantics handle without an onSemanticsUpdate callback.');
      _semanticsOwner = SemanticsOwner(onSemanticsUpdate: onSemanticsUpdate!);
      onSemanticsOwnerCreated?.call();
    }
    if (listener != null) {
      _owner.semanticsOwner!.addListener(listener!);
    }
    return SemanticsHandle(() {
    if (listener != null) {
      _owner.semanticsOwner!.removeListenr(listener!);
    }
   _didDisposeSemanticsHandle();
});
  }

but you will have to expose the constructor.

One more question though, will we have use case that some views enabled semantics but not others? I don't think there is platform that can turn on accessibility for a certain window only.

If that is the case, maybe we should deprecate the pipelineOwner.ensureSemantics, or redirect the call to SemanticsBinding?

I see. I don't think I want to make it easy for people to instantiate SemanticsHandle because doing so is more or less meaningless. A handle only has meaning if it was obtained from one of the ensureSemantics methods.

One more question though, will we have use case that some views enabled semantics but not others? I don't think there is platform that can turn on accessibility for a certain window only.

I can't think of any, really.

If that is the case, maybe we should deprecate the pipelineOwner.ensureSemantics, or redirect the call to SemanticsBinding?

I am considering this for a future change. The PipelineOwner will get a bigger refactoring soon to make it fit for multi view.

sounds good to me

sounds good to me