Flutter Linux Embedder
accessibility_bridge.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "accessibility_bridge.h"
6 
7 #include <functional>
8 #include <utility>
9 
10 #include "flutter/third_party/accessibility/ax/ax_tree_manager_map.h"
11 #include "flutter/third_party/accessibility/ax/ax_tree_update.h"
12 #include "flutter/third_party/accessibility/base/logging.h"
13 
14 namespace flutter { // namespace
15 
16 constexpr int kHasScrollingAction =
17  FlutterSemanticsAction::kFlutterSemanticsActionScrollLeft |
18  FlutterSemanticsAction::kFlutterSemanticsActionScrollRight |
19  FlutterSemanticsAction::kFlutterSemanticsActionScrollUp |
20  FlutterSemanticsAction::kFlutterSemanticsActionScrollDown;
21 
22 // AccessibilityBridge
24  : tree_(std::make_unique<ui::AXTree>()) {
25  event_generator_.SetTree(tree_.get());
26  tree_->AddObserver(static_cast<ui::AXTreeObserver*>(this));
27  ui::AXTreeData data = tree_->data();
28  data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
29  tree_->UpdateData(data);
30  ui::AXTreeManagerMap::GetInstance().AddTreeManager(tree_->GetAXTreeID(),
31  this);
32 }
33 
35  event_generator_.ReleaseTree();
36  tree_->RemoveObserver(static_cast<ui::AXTreeObserver*>(this));
37 }
38 
40  const FlutterSemanticsNode2& node) {
41  pending_semantics_node_updates_[node.id] = FromFlutterSemanticsNode(node);
42 }
43 
45  const FlutterSemanticsCustomAction2& action) {
46  pending_semantics_custom_action_updates_[action.id] =
47  FromFlutterSemanticsCustomAction(action);
48 }
49 
51  // AXTree cannot move a node in a single update.
52  // This must be split across two updates:
53  //
54  // * Update 1: remove nodes from their old parents.
55  // * Update 2: re-add nodes (including their children) to their new parents.
56  //
57  // First, start by removing nodes if necessary.
58  std::optional<ui::AXTreeUpdate> remove_reparented =
59  CreateRemoveReparentedNodesUpdate();
60  if (remove_reparented.has_value()) {
61  tree_->Unserialize(remove_reparented.value());
62 
63  std::string error = tree_->error();
64  if (!error.empty()) {
65  FML_LOG(ERROR) << "Failed to update ui::AXTree, error: " << error;
66  assert(false);
67  return;
68  }
69  }
70 
71  // Second, apply the pending node updates. This also moves reparented nodes to
72  // their new parents if needed.
73  ui::AXTreeUpdate update{.tree_data = tree_->data()};
74 
75  // Figure out update order, ui::AXTree only accepts update in tree order,
76  // where parent node must come before the child node in
77  // ui::AXTreeUpdate.nodes. We start with picking a random node and turn the
78  // entire subtree into a list. We pick another node from the remaining update,
79  // and keep doing so until the update map is empty. We then concatenate the
80  // lists in the reversed order, this guarantees parent updates always come
81  // before child updates. If the root is in the update, it is guaranteed to
82  // be the first node of the last list.
83  std::vector<std::vector<SemanticsNode>> results;
84  while (!pending_semantics_node_updates_.empty()) {
85  auto begin = pending_semantics_node_updates_.begin();
86  SemanticsNode target = begin->second;
87  std::vector<SemanticsNode> sub_tree_list;
88  GetSubTreeList(target, sub_tree_list);
89  results.push_back(sub_tree_list);
90  pending_semantics_node_updates_.erase(begin);
91  }
92 
93  for (size_t i = results.size(); i > 0; i--) {
94  for (const SemanticsNode& node : results[i - 1]) {
95  ConvertFlutterUpdate(node, update);
96  }
97  }
98 
99  // The first update must set the tree's root, which is guaranteed to be the
100  // last list's first node. A tree's root node never changes, though it can be
101  // modified.
102  if (!results.empty() && GetRootAsAXNode()->id() == ui::AXNode::kInvalidAXID) {
103  FML_DCHECK(!results.back().empty());
104 
105  update.root_id = results.back().front().id;
106  }
107 
108  tree_->Unserialize(update);
109  pending_semantics_node_updates_.clear();
110  pending_semantics_custom_action_updates_.clear();
111 
112  std::string error = tree_->error();
113  if (!error.empty()) {
114  FML_LOG(ERROR) << "Failed to update ui::AXTree, error: " << error;
115  return;
116  }
117  // Handles accessibility events as the result of the semantics update.
118  for (const auto& targeted_event : event_generator_) {
119  auto event_target =
120  GetFlutterPlatformNodeDelegateFromID(targeted_event.node->id());
121  if (event_target.expired()) {
122  continue;
123  }
124 
125  OnAccessibilityEvent(targeted_event);
126  }
127  event_generator_.ClearEvents();
128 }
129 
130 std::weak_ptr<FlutterPlatformNodeDelegate>
132  AccessibilityNodeId id) const {
133  const auto iter = id_wrapper_map_.find(id);
134  if (iter != id_wrapper_map_.end()) {
135  return iter->second;
136  }
137 
138  return std::weak_ptr<FlutterPlatformNodeDelegate>();
139 }
140 
141 const ui::AXTreeData& AccessibilityBridge::GetAXTreeData() const {
142  return tree_->data();
143 }
144 
145 const std::vector<ui::AXEventGenerator::TargetedEvent>
147  std::vector<ui::AXEventGenerator::TargetedEvent> result(
148  event_generator_.begin(), event_generator_.end());
149  return result;
150 }
151 
152 void AccessibilityBridge::OnNodeWillBeDeleted(ui::AXTree* tree,
153  ui::AXNode* node) {}
154 
155 void AccessibilityBridge::OnSubtreeWillBeDeleted(ui::AXTree* tree,
156  ui::AXNode* node) {}
157 
158 void AccessibilityBridge::OnNodeReparented(ui::AXTree* tree, ui::AXNode* node) {
159 }
160 
161 void AccessibilityBridge::OnRoleChanged(ui::AXTree* tree,
162  ui::AXNode* node,
163  ax::mojom::Role old_role,
164  ax::mojom::Role new_role) {}
165 
166 void AccessibilityBridge::OnNodeDataChanged(
167  ui::AXTree* tree,
168  const ui::AXNodeData& old_node_data,
169  const ui::AXNodeData& new_node_data) {
170  auto platform_view =
171  GetFlutterPlatformNodeDelegateFromID(new_node_data.id).lock();
172  if (platform_view) {
173  platform_view->NodeDataChanged(old_node_data, new_node_data);
174  }
175 }
176 
177 void AccessibilityBridge::OnNodeCreated(ui::AXTree* tree, ui::AXNode* node) {
178  BASE_DCHECK(node);
179  id_wrapper_map_[node->id()] = CreateFlutterPlatformNodeDelegate();
180  id_wrapper_map_[node->id()]->Init(
181  std::static_pointer_cast<FlutterPlatformNodeDelegate::OwnerBridge>(
182  shared_from_this()),
183  node);
184 }
185 
186 void AccessibilityBridge::OnNodeDeleted(ui::AXTree* tree,
187  AccessibilityNodeId node_id) {
188  BASE_DCHECK(node_id != ui::AXNode::kInvalidAXID);
189  if (id_wrapper_map_.find(node_id) != id_wrapper_map_.end()) {
190  id_wrapper_map_.erase(node_id);
191  }
192 }
193 
194 void AccessibilityBridge::OnAtomicUpdateFinished(
195  ui::AXTree* tree,
196  bool root_changed,
197  const std::vector<ui::AXTreeObserver::Change>& changes) {
198  // The Flutter semantics update does not include child->parent relationship
199  // We have to update the relative bound offset container id here in order
200  // to calculate the screen bound correctly.
201  for (const auto& change : changes) {
202  ui::AXNode* node = change.node;
203  const ui::AXNodeData& data = node->data();
204  AccessibilityNodeId offset_container_id = -1;
205  if (node->parent()) {
206  offset_container_id = node->parent()->id();
207  }
208  node->SetLocation(offset_container_id, data.relative_bounds.bounds,
209  data.relative_bounds.transform.get());
210  }
211 }
212 
213 std::optional<ui::AXTreeUpdate>
214 AccessibilityBridge::CreateRemoveReparentedNodesUpdate() {
215  std::unordered_map<int32_t, ui::AXNodeData> updates;
216 
217  for (const auto& node_update : pending_semantics_node_updates_) {
218  for (int32_t child_id : node_update.second.children_in_traversal_order) {
219  // Skip nodes that don't exist or have a parent in the current tree.
220  ui::AXNode* child = tree_->GetFromId(child_id);
221  if (!child) {
222  continue;
223  }
224 
225  // Flutter's root node should never be reparented.
226  assert(child->parent());
227 
228  // Skip nodes whose parents are unchanged.
229  if (child->parent()->id() == node_update.second.id) {
230  continue;
231  }
232 
233  // This pending update moves the current child node.
234  // That new child must have a corresponding pending update.
235  assert(pending_semantics_node_updates_.find(child_id) !=
236  pending_semantics_node_updates_.end());
237 
238  // Create an update to remove the child from its previous parent.
239  int32_t parent_id = child->parent()->id();
240  if (updates.find(parent_id) == updates.end()) {
241  updates[parent_id] = tree_->GetFromId(parent_id)->data();
242  }
243 
244  ui::AXNodeData* parent = &updates[parent_id];
245  auto iter = std::find(parent->child_ids.begin(), parent->child_ids.end(),
246  child_id);
247 
248  assert(iter != parent->child_ids.end());
249  parent->child_ids.erase(iter);
250  }
251  }
252 
253  if (updates.empty()) {
254  return std::nullopt;
255  }
256 
257  ui::AXTreeUpdate update{
258  .tree_data = tree_->data(),
259  .nodes = std::vector<ui::AXNodeData>(),
260  };
261 
262  for (std::pair<int32_t, ui::AXNodeData> data : updates) {
263  update.nodes.push_back(std::move(data.second));
264  }
265 
266  return update;
267 }
268 
269 // Private method.
270 void AccessibilityBridge::GetSubTreeList(const SemanticsNode& target,
271  std::vector<SemanticsNode>& result) {
272  result.push_back(target);
273  for (int32_t child : target.children_in_traversal_order) {
274  auto iter = pending_semantics_node_updates_.find(child);
275  if (iter != pending_semantics_node_updates_.end()) {
276  SemanticsNode node = iter->second;
277  GetSubTreeList(node, result);
278  pending_semantics_node_updates_.erase(iter);
279  }
280  }
281 }
282 
283 void AccessibilityBridge::ConvertFlutterUpdate(const SemanticsNode& node,
284  ui::AXTreeUpdate& tree_update) {
285  ui::AXNodeData node_data;
286  node_data.id = node.id;
287  SetRoleFromFlutterUpdate(node_data, node);
288  SetStateFromFlutterUpdate(node_data, node);
289  SetActionsFromFlutterUpdate(node_data, node);
290  SetBooleanAttributesFromFlutterUpdate(node_data, node);
291  SetIntAttributesFromFlutterUpdate(node_data, node);
292  SetIntListAttributesFromFlutterUpdate(node_data, node);
293  SetStringListAttributesFromFlutterUpdate(node_data, node);
294  SetIdentifierFromFlutterUpdate(node_data, node);
295  SetNameFromFlutterUpdate(node_data, node);
296  SetValueFromFlutterUpdate(node_data, node);
297  SetTooltipFromFlutterUpdate(node_data, node);
298  node_data.relative_bounds.bounds.SetRect(node.rect.left, node.rect.top,
299  node.rect.right - node.rect.left,
300  node.rect.bottom - node.rect.top);
301  node_data.relative_bounds.transform = std::make_unique<gfx::Transform>(
302  node.transform.scaleX, node.transform.skewX, node.transform.transX, 0,
303  node.transform.skewY, node.transform.scaleY, node.transform.transY, 0,
304  node.transform.pers0, node.transform.pers1, node.transform.pers2, 0, 0, 0,
305  0, 0);
306  for (auto child : node.children_in_traversal_order) {
307  node_data.child_ids.push_back(child);
308  }
309  SetTreeData(node, tree_update);
310  tree_update.nodes.push_back(node_data);
311 }
312 
313 void AccessibilityBridge::SetRoleFromFlutterUpdate(ui::AXNodeData& node_data,
314  const SemanticsNode& node) {
315  const FlutterSemanticsFlags* flags = node.flags;
316  FML_DCHECK(flags) << "SemanticsNode::flags must not be null";
317  if (flags->is_button) {
318  node_data.role = ax::mojom::Role::kButton;
319  return;
320  }
321  if (flags->is_text_field) {
322  node_data.role = ax::mojom::Role::kTextField;
323  return;
324  }
325  if (flags->is_header) {
326  node_data.role = ax::mojom::Role::kHeader;
327  return;
328  }
329  if (flags->is_image) {
330  node_data.role = ax::mojom::Role::kImage;
331  return;
332  }
333  if (flags->is_link) {
334  node_data.role = ax::mojom::Role::kLink;
335  return;
336  }
337 
338  if (flags->is_in_mutually_exclusive_group &&
339  flags->is_checked != FlutterCheckState::kFlutterCheckStateNone) {
340  node_data.role = ax::mojom::Role::kRadioButton;
341  return;
342  }
343  if (flags->is_checked != FlutterCheckState::kFlutterCheckStateNone) {
344  node_data.role = ax::mojom::Role::kCheckBox;
345  return;
346  }
347  if (flags->is_toggled != FlutterTristate::kFlutterTristateNone) {
348  node_data.role = ax::mojom::Role::kSwitch;
349  return;
350  }
351  if (flags->is_slider) {
352  node_data.role = ax::mojom::Role::kSlider;
353  return;
354  }
355  // If the state cannot be derived from the flutter flags, we fallback to group
356  // or static text.
357  if (node.children_in_traversal_order.empty()) {
358  node_data.role = ax::mojom::Role::kStaticText;
359  } else {
360  node_data.role = ax::mojom::Role::kGroup;
361  }
362 }
363 
364 void AccessibilityBridge::SetStateFromFlutterUpdate(ui::AXNodeData& node_data,
365  const SemanticsNode& node) {
366  const FlutterSemanticsFlags* flags = node.flags;
367  FlutterSemanticsAction actions = node.actions;
368  if (flags->is_expanded == FlutterTristate::kFlutterTristateTrue) {
369  node_data.AddState(ax::mojom::State::kExpanded);
370  } else if (flags->is_expanded == FlutterTristate::kFlutterTristateFalse) {
371  node_data.AddState(ax::mojom::State::kCollapsed);
372  }
373  if (flags->is_text_field && !flags->is_read_only) {
374  node_data.AddState(ax::mojom::State::kEditable);
375  }
376  if (flags->is_enabled == FlutterTristate::kFlutterTristateFalse) {
377  node_data.SetRestriction(ax::mojom::Restriction::kDisabled);
378  } else if (flags->is_read_only) {
379  node_data.SetRestriction(ax::mojom::Restriction::kReadOnly);
380  }
381  if (node_data.role == ax::mojom::Role::kStaticText &&
382  (actions & kHasScrollingAction) == 0 && node.value.empty() &&
383  node.label.empty() && node.hint.empty()) {
384  node_data.AddState(ax::mojom::State::kIgnored);
385  } else {
386  // kFlutterSemanticsFlagIsFocusable means a keyboard focusable, it is
387  // different from semantics focusable.
388  // TODO(chunhtai): figure out whether something is not semantics focusable.
389  node_data.AddState(ax::mojom::State::kFocusable);
390  }
391 }
392 
393 void AccessibilityBridge::SetActionsFromFlutterUpdate(
394  ui::AXNodeData& node_data,
395  const SemanticsNode& node) {
396  FlutterSemanticsAction actions = node.actions;
397  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionTap) {
398  node_data.AddAction(ax::mojom::Action::kDoDefault);
399  }
400  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionScrollLeft) {
401  node_data.AddAction(ax::mojom::Action::kScrollLeft);
402  }
403  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionScrollRight) {
404  node_data.AddAction(ax::mojom::Action::kScrollRight);
405  }
406  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionScrollUp) {
407  node_data.AddAction(ax::mojom::Action::kScrollUp);
408  }
409  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionScrollDown) {
410  node_data.AddAction(ax::mojom::Action::kScrollDown);
411  }
412  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionIncrease) {
413  node_data.AddAction(ax::mojom::Action::kIncrement);
414  }
415  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionDecrease) {
416  node_data.AddAction(ax::mojom::Action::kDecrement);
417  }
418  // Every node has show on screen action.
419  node_data.AddAction(ax::mojom::Action::kScrollToMakeVisible);
420 
421  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionSetSelection) {
422  node_data.AddAction(ax::mojom::Action::kSetSelection);
423  }
424  if (actions & FlutterSemanticsAction::
425  kFlutterSemanticsActionDidGainAccessibilityFocus) {
426  node_data.AddAction(ax::mojom::Action::kSetAccessibilityFocus);
427  }
428  if (actions & FlutterSemanticsAction::
429  kFlutterSemanticsActionDidLoseAccessibilityFocus) {
430  node_data.AddAction(ax::mojom::Action::kClearAccessibilityFocus);
431  }
432  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionCustomAction) {
433  node_data.AddAction(ax::mojom::Action::kCustomAction);
434  }
435 }
436 
437 void AccessibilityBridge::SetBooleanAttributesFromFlutterUpdate(
438  ui::AXNodeData& node_data,
439  const SemanticsNode& node) {
440  FlutterSemanticsAction actions = node.actions;
441  const FlutterSemanticsFlags* flags = node.flags;
442  node_data.AddBoolAttribute(ax::mojom::BoolAttribute::kScrollable,
443  actions & kHasScrollingAction);
444  node_data.AddBoolAttribute(
445  ax::mojom::BoolAttribute::kClickable,
446  actions & FlutterSemanticsAction::kFlutterSemanticsActionTap);
447  // TODO(chunhtai): figure out if there is a node that does not clip overflow.
448  node_data.AddBoolAttribute(ax::mojom::BoolAttribute::kClipsChildren,
449  !node.children_in_traversal_order.empty());
450  node_data.AddBoolAttribute(
451  ax::mojom::BoolAttribute::kSelected,
452  flags->is_selected == FlutterTristate::kFlutterTristateTrue);
453  node_data.AddBoolAttribute(ax::mojom::BoolAttribute::kEditableRoot,
454  flags->is_text_field && !flags->is_read_only);
455  // Mark nodes as line breaking so that screen readers don't
456  // merge all consecutive objects into one.
457  // TODO(schectman): When should a node have this attribute set?
458  // https://github.com/flutter/flutter/issues/118184
459  node_data.AddBoolAttribute(ax::mojom::BoolAttribute::kIsLineBreakingObject,
460  true);
461 }
462 
463 void AccessibilityBridge::SetIntAttributesFromFlutterUpdate(
464  ui::AXNodeData& node_data,
465  const SemanticsNode& node) {
466  const FlutterSemanticsFlags* flags = node.flags;
467  node_data.AddIntAttribute(ax::mojom::IntAttribute::kTextDirection,
468  node.text_direction);
469 
470  int sel_start = node.text_selection_base;
471  int sel_end = node.text_selection_extent;
472  if (flags->is_text_field && !flags->is_read_only && !node.value.empty()) {
473  // By default the text field selection should be at the end.
474  sel_start = sel_start == -1 ? node.value.length() : sel_start;
475  sel_end = sel_end == -1 ? node.value.length() : sel_end;
476  }
477  node_data.AddIntAttribute(ax::mojom::IntAttribute::kTextSelStart, sel_start);
478  node_data.AddIntAttribute(ax::mojom::IntAttribute::kTextSelEnd, sel_end);
479 
480  if (node_data.role == ax::mojom::Role::kRadioButton ||
481  node_data.role == ax::mojom::Role::kCheckBox) {
482  node_data.AddIntAttribute(
483  ax::mojom::IntAttribute::kCheckedState,
484  static_cast<int32_t>(
485  (flags->is_checked == FlutterCheckState::kFlutterCheckStateMixed)
486  ? ax::mojom::CheckedState::kMixed
487  : (flags->is_checked == FlutterCheckState::kFlutterCheckStateTrue)
488  ? ax::mojom::CheckedState::kTrue
489  : ax::mojom::CheckedState::kFalse));
490  } else if (node_data.role == ax::mojom::Role::kSwitch) {
491  node_data.AddIntAttribute(
492  ax::mojom::IntAttribute::kCheckedState,
493  static_cast<int32_t>(
494  (flags->is_toggled == FlutterTristate::kFlutterTristateTrue)
495  ? ax::mojom::CheckedState::kTrue
496  : ax::mojom::CheckedState::kFalse));
497  }
498 }
499 
500 void AccessibilityBridge::SetIntListAttributesFromFlutterUpdate(
501  ui::AXNodeData& node_data,
502  const SemanticsNode& node) {
503  FlutterSemanticsAction actions = node.actions;
504  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionCustomAction) {
505  std::vector<int32_t> custom_action_ids;
506  custom_action_ids.reserve(node.custom_accessibility_actions.size());
507  for (size_t i = 0; i < node.custom_accessibility_actions.size(); i++) {
508  custom_action_ids.push_back(node.custom_accessibility_actions[i]);
509  }
510  node_data.AddIntListAttribute(ax::mojom::IntListAttribute::kCustomActionIds,
511  custom_action_ids);
512  }
513 }
514 
515 void AccessibilityBridge::SetStringListAttributesFromFlutterUpdate(
516  ui::AXNodeData& node_data,
517  const SemanticsNode& node) {
518  FlutterSemanticsAction actions = node.actions;
519  if (actions & FlutterSemanticsAction::kFlutterSemanticsActionCustomAction) {
520  std::vector<std::string> custom_action_description;
521  for (size_t i = 0; i < node.custom_accessibility_actions.size(); i++) {
522  auto iter = pending_semantics_custom_action_updates_.find(
523  node.custom_accessibility_actions[i]);
524  BASE_DCHECK(iter != pending_semantics_custom_action_updates_.end());
525  custom_action_description.push_back(iter->second.label);
526  }
527  node_data.AddStringListAttribute(
528  ax::mojom::StringListAttribute::kCustomActionDescriptions,
529  custom_action_description);
530  }
531 }
532 
533 void AccessibilityBridge::SetIdentifierFromFlutterUpdate(
534  ui::AXNodeData& node_data,
535  const SemanticsNode& node) {
536  node_data.AddStringAttribute(ax::mojom::StringAttribute::kIdentifier,
537  node.identifier);
538 }
539 
540 void AccessibilityBridge::SetNameFromFlutterUpdate(ui::AXNodeData& node_data,
541  const SemanticsNode& node) {
542  node_data.SetName(node.label);
543 }
544 
545 void AccessibilityBridge::SetValueFromFlutterUpdate(ui::AXNodeData& node_data,
546  const SemanticsNode& node) {
547  node_data.SetValue(node.value);
548 }
549 
550 void AccessibilityBridge::SetTooltipFromFlutterUpdate(
551  ui::AXNodeData& node_data,
552  const SemanticsNode& node) {
553  node_data.SetTooltip(node.tooltip);
554 }
555 
556 void AccessibilityBridge::SetTreeData(const SemanticsNode& node,
557  ui::AXTreeUpdate& tree_update) {
558  const FlutterSemanticsFlags* flags = node.flags;
559  // Set selection of the focused node if:
560  // 1. this text field has a valid selection
561  // 2. this text field doesn't have a valid selection but had selection stored
562  // in the tree.
563  if (flags->is_text_field &&
564  flags->is_focused == FlutterTristate::kFlutterTristateTrue) {
565  if (node.text_selection_base != -1) {
566  tree_update.tree_data.sel_anchor_object_id = node.id;
567  tree_update.tree_data.sel_anchor_offset = node.text_selection_base;
568  tree_update.tree_data.sel_focus_object_id = node.id;
569  tree_update.tree_data.sel_focus_offset = node.text_selection_extent;
570  tree_update.has_tree_data = true;
571  } else if (tree_update.tree_data.sel_anchor_object_id == node.id) {
572  tree_update.tree_data.sel_anchor_object_id = ui::AXNode::kInvalidAXID;
573  tree_update.tree_data.sel_anchor_offset = -1;
574  tree_update.tree_data.sel_focus_object_id = ui::AXNode::kInvalidAXID;
575  tree_update.tree_data.sel_focus_offset = -1;
576  tree_update.has_tree_data = true;
577  }
578  }
579 
580  if (flags->is_focused == FlutterTristate::kFlutterTristateTrue &&
581  tree_update.tree_data.focus_id != node.id) {
582  tree_update.tree_data.focus_id = node.id;
583  tree_update.has_tree_data = true;
584  } else if (flags->is_focused != FlutterTristate::kFlutterTristateTrue &&
585  tree_update.tree_data.focus_id == node.id) {
586  tree_update.tree_data.focus_id = ui::AXNode::kInvalidAXID;
587  tree_update.has_tree_data = true;
588  }
589 }
590 
591 AccessibilityBridge::SemanticsNode
592 AccessibilityBridge::FromFlutterSemanticsNode(
593  const FlutterSemanticsNode2& flutter_node) {
594  SemanticsNode result;
595  result.id = flutter_node.id;
596  FML_DCHECK(flutter_node.flags2)
597  << "FlutterSemanticsNode2::flags2 must not be null";
598 
599  result.flags = flutter_node.flags2;
600  result.actions = flutter_node.actions;
601  result.heading_level = flutter_node.heading_level;
602  result.text_selection_base = flutter_node.text_selection_base;
603  result.text_selection_extent = flutter_node.text_selection_extent;
604  result.scroll_child_count = flutter_node.scroll_child_count;
605  result.scroll_index = flutter_node.scroll_index;
606  result.scroll_position = flutter_node.scroll_position;
607  result.scroll_extent_max = flutter_node.scroll_extent_max;
608  result.scroll_extent_min = flutter_node.scroll_extent_min;
609  if (flutter_node.label) {
610  result.label = std::string(flutter_node.label);
611  }
612  if (flutter_node.hint) {
613  result.hint = std::string(flutter_node.hint);
614  }
615  if (flutter_node.value) {
616  result.value = std::string(flutter_node.value);
617  }
618  if (flutter_node.increased_value) {
619  result.increased_value = std::string(flutter_node.increased_value);
620  }
621  if (flutter_node.decreased_value) {
622  result.decreased_value = std::string(flutter_node.decreased_value);
623  }
624  if (flutter_node.tooltip) {
625  result.tooltip = std::string(flutter_node.tooltip);
626  }
627  result.text_direction = flutter_node.text_direction;
628  result.rect = flutter_node.rect;
629  result.transform = flutter_node.transform;
630  if (flutter_node.child_count > 0) {
631  result.children_in_traversal_order = std::vector<int32_t>(
632  flutter_node.children_in_traversal_order,
633  flutter_node.children_in_traversal_order + flutter_node.child_count);
634  }
635  if (flutter_node.custom_accessibility_actions_count > 0) {
636  result.custom_accessibility_actions = std::vector<int32_t>(
637  flutter_node.custom_accessibility_actions,
638  flutter_node.custom_accessibility_actions +
639  flutter_node.custom_accessibility_actions_count);
640  }
641  if (flutter_node.identifier) {
642  result.identifier = std::string(flutter_node.identifier);
643  }
644  return result;
645 }
646 
647 AccessibilityBridge::SemanticsCustomAction
648 AccessibilityBridge::FromFlutterSemanticsCustomAction(
649  const FlutterSemanticsCustomAction2& flutter_custom_action) {
650  SemanticsCustomAction result;
651  result.id = flutter_custom_action.id;
652  result.override_action = flutter_custom_action.override_action;
653  if (flutter_custom_action.label) {
654  result.label = std::string(flutter_custom_action.label);
655  }
656  if (flutter_custom_action.hint) {
657  result.hint = std::string(flutter_custom_action.hint);
658  }
659  return result;
660 }
661 
662 void AccessibilityBridge::SetLastFocusedId(AccessibilityNodeId node_id) {
663  if (last_focused_id_ != node_id) {
664  auto last_focused_child =
665  GetFlutterPlatformNodeDelegateFromID(last_focused_id_);
666  if (!last_focused_child.expired()) {
668  last_focused_id_,
669  FlutterSemanticsAction::
670  kFlutterSemanticsActionDidLoseAccessibilityFocus,
671  {});
672  }
673  last_focused_id_ = node_id;
674  }
675 }
676 
677 AccessibilityNodeId AccessibilityBridge::GetLastFocusedId() {
678  return last_focused_id_;
679 }
680 
681 gfx::NativeViewAccessible AccessibilityBridge::GetNativeAccessibleFromId(
682  AccessibilityNodeId id) {
683  auto platform_node_delegate = GetFlutterPlatformNodeDelegateFromID(id).lock();
684  if (!platform_node_delegate) {
685  return nullptr;
686  }
687  return platform_node_delegate->GetNativeViewAccessible();
688 }
689 
690 gfx::RectF AccessibilityBridge::RelativeToGlobalBounds(const ui::AXNode* node,
691  bool& offscreen,
692  bool clip_bounds) {
693  return tree_->RelativeToTreeBounds(node, gfx::RectF(), &offscreen,
694  clip_bounds);
695 }
696 
698  ui::AXTreeID tree_id,
699  ui::AXNode::AXID node_id) const {
700  return GetNodeFromTree(node_id);
701 }
702 
704  ui::AXNode::AXID node_id) const {
705  return tree_->GetFromId(node_id);
706 }
707 
708 ui::AXTreeID AccessibilityBridge::GetTreeID() const {
709  return tree_->GetAXTreeID();
710 }
711 
713  return ui::AXTreeIDUnknown();
714 }
715 
717  return tree_->root();
718 }
719 
721  return nullptr;
722 }
723 
724 ui::AXTree* AccessibilityBridge::GetTree() const {
725  return tree_.get();
726 }
727 
729  const ui::AXNode::AXID node_id) const {
730  auto platform_delegate_weak = GetFlutterPlatformNodeDelegateFromID(node_id);
731  auto platform_delegate = platform_delegate_weak.lock();
732  if (!platform_delegate) {
733  return nullptr;
734  }
735  return platform_delegate->GetPlatformNode();
736 }
737 
739  const ui::AXNode& node) const {
740  return GetPlatformNodeFromTree(node.id());
741 }
742 
743 ui::AXPlatformNodeDelegate* AccessibilityBridge::RootDelegate() const {
745  .lock()
746  .get();
747 }
748 
749 } // namespace flutter
ui::AXTree * GetTree() const override
ui::AXPlatformNodeDelegate * RootDelegate() const override
std::weak_ptr< FlutterPlatformNodeDelegate > GetFlutterPlatformNodeDelegateFromID(AccessibilityNodeId id) const
Get the flutter platform node delegate with the given id from this accessibility bridge....
virtual std::shared_ptr< FlutterPlatformNodeDelegate > CreateFlutterPlatformNodeDelegate()=0
Creates a platform specific FlutterPlatformNodeDelegate. Ownership passes to the caller....
void AddFlutterSemanticsNodeUpdate(const FlutterSemanticsNode2 &node)
Adds a semantics node update to the pending semantics update. Calling this method alone will NOT upda...
void AddFlutterSemanticsCustomActionUpdate(const FlutterSemanticsCustomAction2 &action)
Adds a custom semantics action update to the pending semantics update. Calling this method alone will...
ui::AXPlatformNode * GetPlatformNodeFromTree(const ui::AXNode::AXID node_id) const override
const ui::AXTreeData & GetAXTreeData() const
Get the ax tree data from this accessibility bridge. The tree data contains information such as the i...
ui::AXTreeID GetParentTreeID() const override
ui::AXNode * GetRootAsAXNode() const override
ui::AXNode * GetParentNodeFromParentTreeAsAXNode() const override
AccessibilityBridge()
Creates a new instance of a accessibility bridge.
virtual void OnAccessibilityEvent(ui::AXEventGenerator::TargetedEvent targeted_event)=0
Handle accessibility events generated due to accessibility tree changes. These events are needed to b...
ui::AXTreeID GetTreeID() const override
const std::vector< ui::AXEventGenerator::TargetedEvent > GetPendingEvents() const
Gets all pending accessibility events generated during semantics updates. This is useful when decidin...
void CommitUpdates()
Flushes the pending updates and applies them to this accessibility bridge. Calling this with no pendi...
ui::AXNode * GetNodeFromTree(const ui::AXTreeID tree_id, const ui::AXNode::AXID node_id) const override
virtual void DispatchAccessibilityAction(AccessibilityNodeId target, FlutterSemanticsAction action, fml::MallocMapping data)=0
Dispatch accessibility action back to the Flutter framework. These actions are generated in the nativ...
const uint8_t uint32_t uint32_t GError ** error
uint32_t * target
constexpr int kHasScrollingAction
ui::AXNode::AXID AccessibilityNodeId