flutter_runner::AccessibilityBridge Class Reference

#include <accessibility_bridge.h>

Inheritance diagram for flutter_runner::AccessibilityBridge:

Public Types
using	SetSemanticsEnabledCallback = std::function< void(bool)>
using	DispatchSemanticsActionCallback = std::function< void(int32_t, flutter::SemanticsAction)>

Public Member Functions
	AccessibilityBridge (SetSemanticsEnabledCallback set_semantics_enabled_callback, DispatchSemanticsActionCallback dispatch_semantics_action_callback, fuchsia::accessibility::semantics::SemanticsManagerHandle semantics_manager, fuchsia::ui::views::ViewRef view_ref, inspect::Node inspect_node)
bool	GetSemanticsEnabled () const
void	SetSemanticsEnabled (bool enabled)
void	AddSemanticsNodeUpdate (const flutter::SemanticsNodeUpdates update, float view_pixel_ratio)
void	RequestAnnounce (const std::string message)
zx_status_t	OnHoverMove (double x, double y)
void	HitTest (fuchsia::math::PointF local_point, fuchsia::accessibility::semantics::SemanticListener::HitTestCallback callback) override
void	OnAccessibilityActionRequested (uint32_t node_id, fuchsia::accessibility::semantics::Action action, fuchsia::accessibility::semantics::SemanticListener::OnAccessibilityActionRequestedCallback callback) override

Static Public Attributes
static constexpr uint32_t	kMaxMessageSize = ZX_CHANNEL_MAX_MSG_BYTES / 2
static constexpr size_t	kNodeIdSize = sizeof(flutter::SemanticsNode::id)
static constexpr size_t	kMaxDeletionsPerUpdate

Detailed Description

Definition at line 41 of file accessibility_bridge.h.

Member Typedef Documentation

DispatchSemanticsActionCallback

using flutter_runner::AccessibilityBridge::DispatchSemanticsActionCallback = std::function<void(int32_t, flutter::SemanticsAction)>

Definition at line 45 of file accessibility_bridge.h.

SetSemanticsEnabledCallback

using flutter_runner::AccessibilityBridge::SetSemanticsEnabledCallback = std::function<void(bool)>

Definition at line 44 of file accessibility_bridge.h.

Constructor & Destructor Documentation

AccessibilityBridge()

flutter_runner::AccessibilityBridge::AccessibilityBridge	(	SetSemanticsEnabledCallback	set_semantics_enabled_callback,
		DispatchSemanticsActionCallback	dispatch_semantics_action_callback,
		fuchsia::accessibility::semantics::SemanticsManagerHandle	semantics_manager,
		fuchsia::ui::views::ViewRef	view_ref,
		inspect::Node	inspect_node
	)

Definition at line 221 of file accessibility_bridge.cc.

    : set_semantics_enabled_callback_(
          std::move(set_semantics_enabled_callback)),
      dispatch_semantics_action_callback_(
          std::move(dispatch_semantics_action_callback)),
      binding_(this),
      fuchsia_semantics_manager_(semantics_manager.Bind()),
      atomic_updates_(std::make_shared<std::queue<FuchsiaAtomicUpdate>>()),
      inspect_node_(std::move(inspect_node)) {
  fuchsia_semantics_manager_.set_error_handler([](zx_status_t status) {
    FML_LOG(ERROR) << "Flutter cannot connect to SemanticsManager with status: "
                   << zx_status_get_string(status) << ".";
  });
  fuchsia_semantics_manager_->RegisterViewForSemantics(
      std::move(view_ref), binding_.NewBinding(), tree_ptr_.NewRequest());
 
#if !FLUTTER_RELEASE
  // The first argument to |CreateLazyValues| is the name of the lazy node, and
  // will only be displayed if the callback used to generate the node's content
  // fails. Therefore, we use an error message for this node name.
  inspect_node_tree_dump_ =
      inspect_node_.CreateLazyValues("dump_fail", [this]() {
        inspect::Inspector inspector;
        if (auto it = nodes_.find(kRootNodeId); it == nodes_.end()) {
          inspector.GetRoot().CreateString(
              "empty_tree", "this semantic tree is empty", &inspector);
        } else {
          FillInspectTree(
              kRootNodeId, /*current_level=*/1,
              inspector.GetRoot().CreateChild(kTreeDumpInspectRootName),
              &inspector);
        }
        return fpromise::make_ok_promise(std::move(inspector));
      });
#endif  // !FLUTTER_RELEASE
}

Member Function Documentation

AddSemanticsNodeUpdate()

void flutter_runner::AccessibilityBridge::AddSemanticsNodeUpdate	(	const flutter::SemanticsNodeUpdates	update,
		float	view_pixel_ratio
	)

Definition at line 526 of file accessibility_bridge.cc.

                            {
  if (update.empty()) {
    return;
  }
  FML_DCHECK(nodes_.find(kRootNodeId) != nodes_.end() ||
             update.find(kRootNodeId) != update.end())
      << "AccessibilityBridge received an update with out ever getting a root "
         "node.";
 
  FuchsiaAtomicUpdate atomic_update;
  bool has_root_node_update = false;
  // TODO(MI4-2498): Actions, Roles, hit test children, additional
  // flags/states/attr
 
  // TODO(MI4-1478): Support for partial updates for nodes > 64kb
  // e.g. if a node has a long label or more than 64k children.
  for (const auto& [flutter_node_id, flutter_node] : update) {
    size_t this_node_size = sizeof(fuchsia::accessibility::semantics::Node);
    // We handle root update separately in GetRootNodeUpdate.
    // TODO(chunhtai): remove this special case after we remove the inverse
    // view pixel ratio transformation in scenic view.
    // TODO(http://fxbug.dev/75908): Investigate flutter a11y bridge refactor
    // after removal of the inverse view pixel ratio transformation in scenic
    // view).
    if (flutter_node.id == kRootNodeId) {
      root_flutter_semantics_node_ = flutter_node;
      has_root_node_update = true;
      continue;
    }
    // Store the nodes for later hit testing and logging.
    nodes_[flutter_node.id].data = flutter_node;
 
    fuchsia::accessibility::semantics::Node fuchsia_node;
    std::vector<uint32_t> child_ids;
    // Send the nodes in traversal order, so the manager can figure out
    // traversal.
    for (int32_t flutter_child_id : flutter_node.childrenInTraversalOrder) {
      child_ids.push_back(FlutterIdToFuchsiaId(flutter_child_id));
    }
    // TODO(http://fxbug.dev/75910): check the usage of FlutterIdToFuchsiaId in
    // the flutter accessibility bridge.
    fuchsia_node.set_node_id(flutter_node.id)
        .set_role(GetNodeRole(flutter_node))
        .set_location(GetNodeLocation(flutter_node))
        .set_transform(GetNodeTransform(flutter_node))
        .set_attributes(GetNodeAttributes(flutter_node, &this_node_size))
        .set_states(GetNodeStates(flutter_node, &this_node_size))
        .set_actions(GetNodeActions(flutter_node, &this_node_size))
        .set_child_ids(child_ids);
    this_node_size +=
        kNodeIdSize * flutter_node.childrenInTraversalOrder.size();
 
    atomic_update.AddNodeUpdate(std::move(fuchsia_node), this_node_size);
  }
 
  // Handles root node update.
  if (has_root_node_update || last_seen_view_pixel_ratio_ != view_pixel_ratio) {
    last_seen_view_pixel_ratio_ = view_pixel_ratio;
    size_t root_node_size;
    fuchsia::accessibility::semantics::Node root_update =
        GetRootNodeUpdate(root_node_size);
    atomic_update.AddNodeUpdate(std::move(root_update), root_node_size);
  }
 
  PruneUnreachableNodes(&atomic_update);
  UpdateScreenRects();
 
  atomic_updates_->push(std::move(atomic_update));
  if (atomic_updates_->size() == 1) {
    // There were no commits in the queue, so send this one.
    Apply(&atomic_updates_->front());
  }
}

GetSemanticsEnabled()

bool flutter_runner::AccessibilityBridge::GetSemanticsEnabled

(

)

const

Definition at line 263 of file accessibility_bridge.cc.

                                                    {
  return semantics_enabled_;
}

HitTest()

void flutter_runner::AccessibilityBridge::HitTest ( fuchsia::math::PointF  local_point, fuchsia::accessibility::semantics::SemanticListener::HitTestCallback  callback  )

override

Definition at line 759 of file accessibility_bridge.cc.

                  {
  auto hit_node_id = GetHitNode(kRootNodeId, local_point.x, local_point.y);
  FML_DCHECK(hit_node_id.has_value());
  fuchsia::accessibility::semantics::Hit hit;
  // TODO(http://fxbug.dev/75910): check the usage of FlutterIdToFuchsiaId in
  // the flutter accessibility bridge.
  hit.set_node_id(hit_node_id.value_or(kRootNodeId));
  callback(std::move(hit));
}

OnAccessibilityActionRequested()

void flutter_runner::AccessibilityBridge::OnAccessibilityActionRequested ( uint32_t  node_id, fuchsia::accessibility::semantics::Action  action, fuchsia::accessibility::semantics::SemanticListener::OnAccessibilityActionRequestedCallback  callback  )

override

Definition at line 732 of file accessibility_bridge.cc.

                                                         {
  // TODO(http://fxbug.dev/75910): check the usage of FlutterIdToFuchsiaId in
  // the flutter accessibility bridge.
  if (nodes_.find(node_id) == nodes_.end()) {
    FML_LOG(ERROR) << "Attempted to send accessibility action "
                   << static_cast<int32_t>(action)
                   << " to unknown node id: " << node_id;
    callback(false);
    return;
  }
 
  std::optional<flutter::SemanticsAction> flutter_action =
      GetFlutterSemanticsAction(action, node_id);
  if (!flutter_action.has_value()) {
    callback(false);
    return;
  }
  dispatch_semantics_action_callback_(static_cast<int32_t>(node_id),
                                      flutter_action.value());
  callback(true);
}

OnHoverMove()

zx_status_t flutter_runner::AccessibilityBridge::OnHoverMove	(	double	x,
		double	y
	)

RequestAnnounce()

void flutter_runner::AccessibilityBridge::RequestAnnounce

(

const std::string

message

)

Definition at line 637 of file accessibility_bridge.cc.

                                                                 {
  fuchsia::accessibility::semantics::SemanticEvent semantic_event;
  fuchsia::accessibility::semantics::AnnounceEvent announce_event;
  announce_event.set_message(message);
  semantic_event.set_announce(std::move(announce_event));
 
  tree_ptr_->SendSemanticEvent(std::move(semantic_event), []() {});
}

SetSemanticsEnabled()

void flutter_runner::AccessibilityBridge::SetSemanticsEnabled

(

bool

enabled

)

Definition at line 267 of file accessibility_bridge.cc.

                                                          {
  semantics_enabled_ = enabled;
  if (!enabled) {
    nodes_.clear();
  }
}

Member Data Documentation

kMaxDeletionsPerUpdate

constexpr size_t flutter_runner::AccessibilityBridge::kMaxDeletionsPerUpdate

staticconstexpr

Initial value:

=
      kMaxMessageSize / kNodeIdSize

Definition at line 68 of file accessibility_bridge.h.

kMaxMessageSize

constexpr uint32_t flutter_runner::AccessibilityBridge::kMaxMessageSize = ZX_CHANNEL_MAX_MSG_BYTES / 2

staticconstexpr

Definition at line 52 of file accessibility_bridge.h.

kNodeIdSize

constexpr size_t flutter_runner::AccessibilityBridge::kNodeIdSize = sizeof(flutter::SemanticsNode::id)

staticconstexpr

Definition at line 60 of file accessibility_bridge.h.

---

The documentation for this class was generated from the following files:

• shell/platform/fuchsia/flutter/accessibility_bridge.h
• shell/platform/fuchsia/flutter/accessibility_bridge.cc