SemanticsObject Class Reference

#include <SemanticsObject.h>

Inheritance diagram for SemanticsObject:

Instance Methods
(BOOL)	- isAccessibilityBridgeAlive
(void)	- setSemanticsNode:
(void)	- replaceChildAtIndex:withChild:
(BOOL)	- nodeWillCauseLayoutChange:
(BOOL)	- nodeWillCauseScroll:
(BOOL)	- nodeShouldTriggerAnnouncement:
(void)	- collectRoutes:
(NSString *)	- routeName
(BOOL)	- onCustomAccessibilityAction:
(void)	- accessibilityBridgeDidFinishUpdate
((unavailable("Use initWithBridge instead")	- __attribute__
(instancetype)	- initWithBridge:uid:
(instancetype)	- init [implementation]
(void)	- dealloc [implementation]
(void)	- setChildren: [implementation]
(void)	- setChildrenInHitTestOrder: [implementation]
(void)	- privateSetParent: [implementation]
(NSAttributedString *)	- createAttributedStringFromString:withAttributes: [implementation]
(void)	- showOnScreen [implementation]
(BOOL)	- isAccessibilityElement [implementation]
(bool)	- isFocusable [implementation]
(NSString *)	- accessibilityIdentifier [implementation]
(NSString *)	- accessibilityLabel [implementation]
(bool)	- containsPoint: [implementation]
(id)	- search: [implementation]
(id)	- _accessibilityHitTest:withEvent: [implementation]
(BOOL)	- accessibilityScrollToVisible [implementation]
(BOOL)	- accessibilityScrollToVisibleWithChild: [implementation]
(NSAttributedString *)	- accessibilityAttributedLabel [implementation]
(NSString *)	- accessibilityHint [implementation]
(NSAttributedString *)	- accessibilityAttributedHint [implementation]
(NSString *)	- accessibilityValue [implementation]
(NSAttributedString *)	- accessibilityAttributedValue [implementation]
(CGRect)	- accessibilityFrame [implementation]
(CGRect)	- globalRect [implementation]
(void)	- setAccessibilityContainer: [implementation]
(id)	- accessibilityContainer [implementation]
(BOOL)	- accessibilityActivate [implementation]
(void)	- accessibilityIncrement [implementation]
(void)	- accessibilityDecrement [implementation]
(BOOL)	- accessibilityScroll: [implementation]
(BOOL)	- accessibilityPerformEscape [implementation]
(void)	- accessibilityElementDidBecomeFocused [implementation]
(void)	- accessibilityElementDidLoseFocus [implementation]

Properties
int32_t	uid
SemanticsObject *	parent
fml::WeakPtr< flutter::AccessibilityBridgeIos >	bridge
flutter::SemanticsNode	node
BOOL	hasChildren
NSArray< SemanticsObject * > *	children
NSArray< SemanticsObject * > *	childrenInHitTestOrder
id	nativeAccessibility

Detailed Description

A node in the iOS semantics tree. This object is a wrapper over a native accessibiliy object, which is stored in the property nativeAccessibility. In the most case, the nativeAccessibility directly returns this object. Some subclasses such as the FlutterScrollableSemanticsObject creates a native UIScrollView as its nativeAccessibility so that it can interact with iOS.

Definition at line 30 of file SemanticsObject.h.

Method Documentation

__attribute__

- ((unavailable("Use initWithBridge instead") __attribute__

_accessibilityHitTest:withEvent:

- (id) _accessibilityHitTest: (CGPoint)  point withEvent: (UIEvent*)  event

implementation

Provided by category SemanticsObject(Tests).

Definition at line 269 of file SemanticsObject.mm.

                           :(CGPoint)point withEvent:(UIEvent*)event {
  return [self search:point];
}

accessibilityActivate

- (BOOL) accessibilityActivate

implementation

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                              {
  if (![self isAccessibilityBridgeAlive]) {
    return NO;
  }
  if (![self node].HasAction(flutter::SemanticsAction::kTap)) {
    return NO;
  }
  [self bridge]->DispatchSemanticsAction([self uid], flutter::SemanticsAction::kTap);
  return YES;
}

accessibilityAttributedHint

- (NSAttributedString *) accessibilityAttributedHint

implementation

Definition at line 269 of file SemanticsObject.mm.

                                                   {
  NSString* hint = [self accessibilityHint];
  if (hint.length == 0) {
    return nil;
  }
  return [self createAttributedStringFromString:hint withAttributes:[self node].hintAttributes];
}

accessibilityAttributedLabel

- (NSAttributedString *) accessibilityAttributedLabel

implementation

Definition at line 269 of file SemanticsObject.mm.

                                                    {
  NSString* label = [self accessibilityLabel];
  if (label.length == 0) {
    return nil;
  }
  return [self createAttributedStringFromString:label withAttributes:[self node].labelAttributes];
}

accessibilityAttributedValue

- (NSAttributedString *) accessibilityAttributedValue

implementation

Definition at line 269 of file SemanticsObject.mm.

                                                    {
  NSString* value = [self accessibilityValue];
  if (value.length == 0) {
    return nil;
  }
  return [self createAttributedStringFromString:value withAttributes:[self node].valueAttributes];
}

accessibilityBridgeDidFinishUpdate

- (void) accessibilityBridgeDidFinishUpdate

Called after accessibility bridge finishes a semantics update.

Subclasses can override this method if they contain states that can only be updated once every node in the accessibility tree has finished updating.

Reimplemented in FlutterScrollableSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                                           { /* Do nothing by default */
}

accessibilityContainer

- (id) accessibilityContainer

implementation

Definition at line 269 of file SemanticsObject.mm.

                             {
  if (_inDealloc) {
    // In iOS9, `accessibilityContainer` will be called by `[UIAccessibilityElementSuperCategory
    // dealloc]` during `[super dealloc]`. And will crash when accessing `_children` which has
    // called `[_children release]` in `[SemanticsObject dealloc]`.
    // https://github.com/flutter/flutter/issues/87247
    return nil;
  }
 
  if (![self isAccessibilityBridgeAlive]) {
    return nil;
  }
 
  if ([self hasChildren] || [self uid] == kRootNodeId) {
    if (_container == nil) {
      _container.reset([[SemanticsObjectContainer alloc] initWithSemanticsObject:self
                                                                          bridge:[self bridge]]);
    }
    return _container.get();
  }
  if ([self parent] == nil) {
    // This can happen when we have released the accessibility tree but iOS is
    // still holding onto our objects. iOS can take some time before it
    // realizes that the tree has changed.
    return nil;
  }
  return [[self parent] accessibilityContainer];
}

accessibilityDecrement

- (void) accessibilityDecrement

implementation

Definition at line 269 of file SemanticsObject.mm.

                               {
  if (![self isAccessibilityBridgeAlive]) {
    return;
  }
  if ([self node].HasAction(flutter::SemanticsAction::kDecrease)) {
    [self node].value = [self node].decreasedValue;
    [self bridge]->DispatchSemanticsAction([self uid], flutter::SemanticsAction::kDecrease);
  }
}

accessibilityElementDidBecomeFocused

- (void) accessibilityElementDidBecomeFocused

implementation

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                                             {
  if (![self isAccessibilityBridgeAlive]) {
    return;
  }
  [self bridge]->AccessibilityObjectDidBecomeFocused([self uid]);
  if ([self node].HasFlag(flutter::SemanticsFlags::kIsHidden) ||
      [self node].HasFlag(flutter::SemanticsFlags::kIsHeader)) {
    [self showOnScreen];
  }
  if ([self node].HasAction(flutter::SemanticsAction::kDidGainAccessibilityFocus)) {
    [self bridge]->DispatchSemanticsAction([self uid],
                                           flutter::SemanticsAction::kDidGainAccessibilityFocus);
  }
}

accessibilityElementDidLoseFocus

- (void) accessibilityElementDidLoseFocus

implementation

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                                         {
  if (![self isAccessibilityBridgeAlive]) {
    return;
  }
  [self bridge]->AccessibilityObjectDidLoseFocus([self uid]);
  if ([self node].HasAction(flutter::SemanticsAction::kDidLoseAccessibilityFocus)) {
    [self bridge]->DispatchSemanticsAction([self uid],
                                           flutter::SemanticsAction::kDidLoseAccessibilityFocus);
  }
}

accessibilityFrame

- (CGRect) accessibilityFrame

implementation

Definition at line 269 of file SemanticsObject.mm.

                             {
  if (![self isAccessibilityBridgeAlive]) {
    return CGRectMake(0, 0, 0, 0);
  }
 
  if ([self node].HasFlag(flutter::SemanticsFlags::kIsHidden)) {
    return [super accessibilityFrame];
  }
  return [self globalRect];
}

accessibilityHint

- (NSString *) accessibilityHint

implementation

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                               {
  if (![self isAccessibilityBridgeAlive]) {
    return nil;
  }
 
  if ([self node].hint.empty()) {
    return nil;
  }
  return @([self node].hint.data());
}

accessibilityIdentifier

- (NSString *) accessibilityIdentifier

implementation

Definition at line 269 of file SemanticsObject.mm.

                                     {
  if (![self isAccessibilityBridgeAlive]) {
    return nil;
  }
 
  if ([self node].identifier.empty()) {
    return nil;
  }
  return @([self node].identifier.data());
}

accessibilityIncrement

- (void) accessibilityIncrement

implementation

Definition at line 269 of file SemanticsObject.mm.

                               {
  if (![self isAccessibilityBridgeAlive]) {
    return;
  }
  if ([self node].HasAction(flutter::SemanticsAction::kIncrease)) {
    [self node].value = [self node].increasedValue;
    [self bridge]->DispatchSemanticsAction([self uid], flutter::SemanticsAction::kIncrease);
  }
}

accessibilityLabel

- (NSString *) accessibilityLabel

implementation

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                                {
  if (![self isAccessibilityBridgeAlive]) {
    return nil;
  }
  NSString* label = nil;
  if (![self node].label.empty()) {
    label = @([self node].label.data());
  }
  if (![self node].tooltip.empty()) {
    label = label ? [NSString stringWithFormat:@"%@\n%@", label, @([self node].tooltip.data())]
                  : @([self node].tooltip.data());
  }
  return label;
}

accessibilityPerformEscape

- (BOOL) accessibilityPerformEscape

implementation

Definition at line 269 of file SemanticsObject.mm.

                                   {
  if (![self isAccessibilityBridgeAlive]) {
    return NO;
  }
  if (![self node].HasAction(flutter::SemanticsAction::kDismiss)) {
    return NO;
  }
  [self bridge]->DispatchSemanticsAction([self uid], flutter::SemanticsAction::kDismiss);
  return YES;
}

accessibilityScroll:

- (BOOL) accessibilityScroll: (UIAccessibilityScrollDirection)  direction

implementation

Definition at line 269 of file SemanticsObject.mm.

                           :(UIAccessibilityScrollDirection)direction {
  if (![self isAccessibilityBridgeAlive]) {
    return NO;
  }
  flutter::SemanticsAction action = GetSemanticsActionForScrollDirection(direction);
  if (![self node].HasAction(action)) {
    return NO;
  }
  [self bridge]->DispatchSemanticsAction([self uid], action);
  return YES;
}

accessibilityScrollToVisible

- (BOOL) accessibilityScrollToVisible

implementation

Provided by category SemanticsObject(Tests).

Definition at line 269 of file SemanticsObject.mm.

                                     {
  [self showOnScreen];
  return YES;
}

accessibilityScrollToVisibleWithChild:

- (BOOL) accessibilityScrollToVisibleWithChild: (id)  child

implementation

Provided by category SemanticsObject(Tests).

Definition at line 269 of file SemanticsObject.mm.

                                             :(id)child {
  if ([child isKindOfClass:[SemanticsObject class]]) {
    [child showOnScreen];
    return YES;
  }
  return NO;
}

accessibilityValue

- (NSString *) accessibilityValue

implementation

Reimplemented in TextInputSemanticsObject, and FlutterSwitchSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                                {
  if (![self isAccessibilityBridgeAlive]) {
    return nil;
  }
 
  if (![self node].value.empty()) {
    return @([self node].value.data());
  }
 
  // iOS does not announce values of native radio buttons.
  if ([self node].HasFlag(flutter::SemanticsFlags::kIsInMutuallyExclusiveGroup)) {
    return nil;
  }
 
  // FlutterSwitchSemanticsObject should supercede these conditionals.
  if ([self node].HasFlag(flutter::SemanticsFlags::kHasToggledState) ||
      [self node].HasFlag(flutter::SemanticsFlags::kHasCheckedState)) {
    if ([self node].HasFlag(flutter::SemanticsFlags::kIsToggled) ||
        [self node].HasFlag(flutter::SemanticsFlags::kIsChecked)) {
      return @"1";
    } else {
      return @"0";
    }
  }
 
  return nil;
}

collectRoutes:

- (void) collectRoutes:

(NSMutableArray<SemanticsObject*>*)

edges

Definition at line 269 of file SemanticsObject.mm.

                     :(NSMutableArray<SemanticsObject*>*)edges {
  if ([self node].HasFlag(flutter::SemanticsFlags::kScopesRoute)) {
    [edges addObject:self];
  }
  if ([self hasChildren]) {
    for (SemanticsObject* child in self.children) {
      [child collectRoutes:edges];
    }
  }
}

containsPoint:

- (bool) containsPoint: (CGPoint)  point

implementation

Definition at line 269 of file SemanticsObject.mm.

                     :(CGPoint)point {
  // The point is in global coordinates, so use the global rect here.
  return CGRectContainsPoint([self globalRect], point);
}

createAttributedStringFromString:withAttributes:

- (NSAttributedString *) createAttributedStringFromString: (NSString*)  string withAttributes: (const flutter::StringAttributes&)  attributes

implementation

Definition at line 269 of file SemanticsObject.mm.

                                                       :(NSString*)string
                                         withAttributes:
                                             (const flutter::StringAttributes&)attributes {
  NSMutableAttributedString* attributedString =
      [[[NSMutableAttributedString alloc] initWithString:string] autorelease];
  for (const auto& attribute : attributes) {
    NSRange range = NSMakeRange(attribute->start, attribute->end - attribute->start);
    switch (attribute->type) {
      case flutter::StringAttributeType::kLocale: {
        std::shared_ptr<flutter::LocaleStringAttribute> locale_attribute =
            std::static_pointer_cast<flutter::LocaleStringAttribute>(attribute);
        NSDictionary* attributeDict = @{
          UIAccessibilitySpeechAttributeLanguage : @(locale_attribute->locale.data()),
        };
        [attributedString setAttributes:attributeDict range:range];
        break;
      }
      case flutter::StringAttributeType::kSpellOut: {
        if (@available(iOS 13.0, *)) {
          NSDictionary* attributeDict = @{
            UIAccessibilitySpeechAttributeSpellOut : @YES,
          };
          [attributedString setAttributes:attributeDict range:range];
        }
        break;
      }
    }
  }
  return attributedString;
}

dealloc

- (void) dealloc

implementation

Reimplemented in TextInputSemanticsObject, FlutterSwitchSemanticsObject, FlutterScrollableSemanticsObject, and FlutterPlatformViewSemanticsContainer.

Definition at line 269 of file SemanticsObject.mm.

                {
  for (SemanticsObject* child in _children) {
    [child privateSetParent:nil];
  }
  [_children removeAllObjects];
  [_childrenInHitTestOrder removeAllObjects];
  [_children release];
  [_childrenInHitTestOrder release];
 
  _parent = nil;
  _container.get().semanticsObject = nil;
  _inDealloc = YES;
  [super dealloc];
}

globalRect

- (CGRect) globalRect

implementation

Definition at line 269 of file SemanticsObject.mm.

                     {
  const SkRect& rect = [self node].rect;
  CGRect localRect = CGRectMake(rect.x(), rect.y(), rect.width(), rect.height());
  return ConvertRectToGlobal(self, localRect);
}

init

- (instancetype) init

implementation

Definition at line 269 of file SemanticsObject.mm.

                     {
  [self release];
  [super doesNotRecognizeSelector:_cmd];
  return nil;
}

initWithBridge:uid:

- (instancetype) initWithBridge:		(fml::WeakPtr<flutter::AccessibilityBridgeIos>)	bridge
uid:		(int32_t)	NS_DESIGNATED_INITIALIZER

Reimplemented in TextInputSemanticsObject, FlutterSwitchSemanticsObject, FlutterScrollableSemanticsObject, and FlutterPlatformViewSemanticsContainer.

Definition at line 269 of file SemanticsObject.mm.

                              :(fml::WeakPtr<flutter::AccessibilityBridgeIos>)bridge
                           uid:(int32_t)uid {
  FML_DCHECK(bridge) << "bridge must be set";
  FML_DCHECK(uid >= kRootNodeId);
  // Initialize with the UIView as the container.
  // The UIView will not necessarily be accessibility parent for this object.
  // The bridge informs the OS of the actual structure via
  // `accessibilityContainer` and `accessibilityElementAtIndex`.
  self = [super initWithAccessibilityContainer:bridge->view()];
 
  if (self) {
    _bridge = bridge;
    _uid = uid;
    _children = [[NSMutableArray alloc] init];
    _childrenInHitTestOrder = [[NSMutableArray alloc] init];
  }
 
  return self;
}

isAccessibilityBridgeAlive

- (BOOL) isAccessibilityBridgeAlive

Due to the fact that VoiceOver may hold onto SemanticObjects even after it shuts down, there can be situations where the AccessibilityBridge is shutdown, but the SemanticObject will still be alive. If VoiceOver is turned on again, it may try to access this orphaned SemanticObject. Methods that are called from the accessiblity framework should use this to guard against this case by just returning early if its bridge has been shutdown.

See https://github.com/flutter/flutter/issues/43795 for more information.

Definition at line 269 of file SemanticsObject.mm.

                                   {
  return [self bridge].get() != nil;
}

isAccessibilityElement

- (BOOL) isAccessibilityElement

implementation

Definition at line 269 of file SemanticsObject.mm.

                               {
  if (![self isAccessibilityBridgeAlive]) {
    return false;
  }
 
  // Note: hit detection will only apply to elements that report
  // -isAccessibilityElement of YES. The framework will continue scanning the
  // entire element tree looking for such a hit.
 
  //  We enforce in the framework that no other useful semantics are merged with these nodes.
  if ([self node].HasFlag(flutter::SemanticsFlags::kScopesRoute)) {
    return false;
  }
 
  return [self isFocusable];
}

isFocusable

- (bool) isFocusable

implementation

Definition at line 269 of file SemanticsObject.mm.

                    {
  // If the node is scrollable AND hidden OR
  // The node has a label, value, or hint OR
  // The node has non-scrolling related actions.
  //
  // The kIsHidden flag set with the scrollable flag means this node is now
  // hidden but still is a valid target for a11y focus in the tree, e.g. a list
  // item that is currently off screen but the a11y navigation needs to know
  // about.
  return (([self node].flags & flutter::kScrollableSemanticsFlags) != 0 &&
          ([self node].flags & static_cast<int32_t>(flutter::SemanticsFlags::kIsHidden)) != 0) ||
         ![self node].label.empty() || ![self node].value.empty() || ![self node].hint.empty() ||
         ([self node].actions & ~flutter::kScrollableSemanticsActions) != 0;
}

nodeShouldTriggerAnnouncement:

- (BOOL) nodeShouldTriggerAnnouncement:

(const flutter::SemanticsNode*)

node

Whether calling setSemanticsNode: with node should trigger an announcement.

Definition at line 269 of file SemanticsObject.mm.

                                     :(const flutter::SemanticsNode*)node {
  // The node dropped the live region flag, if it ever had one.
  if (!node || !node->HasFlag(flutter::SemanticsFlags::kIsLiveRegion)) {
    return NO;
  }
 
  // The node has gained a new live region flag, always announce.
  if (![self node].HasFlag(flutter::SemanticsFlags::kIsLiveRegion)) {
    return YES;
  }
 
  // The label has updated, and the new node has a live region flag.
  return [self node].label != node->label;
}

nodeWillCauseLayoutChange:

- (BOOL) nodeWillCauseLayoutChange:

(const flutter::SemanticsNode*)

node

Whether calling setSemanticsNode: with node would cause a layout change.

Definition at line 269 of file SemanticsObject.mm.

                                 :(const flutter::SemanticsNode*)node {
  return [self node].rect != node->rect || [self node].transform != node->transform;
}

nodeWillCauseScroll:

- (BOOL) nodeWillCauseScroll:

(const flutter::SemanticsNode*)

node

Whether calling setSemanticsNode: with node would cause a scroll event.

Definition at line 269 of file SemanticsObject.mm.

                           :(const flutter::SemanticsNode*)node {
  return !isnan([self node].scrollPosition) && !isnan(node->scrollPosition) &&
         [self node].scrollPosition != node->scrollPosition;
}

onCustomAccessibilityAction:

- (BOOL) onCustomAccessibilityAction:

(FlutterCustomAccessibilityAction*)

action

Definition at line 269 of file SemanticsObject.mm.

                                   :(FlutterCustomAccessibilityAction*)action {
  if (![self node].HasAction(flutter::SemanticsAction::kCustomAction)) {
    return NO;
  }
  int32_t action_id = action.uid;
  std::vector<uint8_t> args;
  args.push_back(3);  // type=int32.
  args.push_back(action_id);
  args.push_back(action_id >> 8);
  args.push_back(action_id >> 16);
  args.push_back(action_id >> 24);
  [self bridge]->DispatchSemanticsAction(
      [self uid], flutter::SemanticsAction::kCustomAction,
      fml::MallocMapping::Copy(args.data(), args.size() * sizeof(uint8_t)));
  return YES;
}

privateSetParent:

- (void) privateSetParent: (SemanticsObject *)  parent

implementation

Should only be called in conjunction with setting child/parent relationship.

Definition at line 269 of file SemanticsObject.mm.

                        :(SemanticsObject*)parent {
  _parent = parent;
}

replaceChildAtIndex:withChild:

- (void) replaceChildAtIndex:		(NSInteger)	index
withChild:		(SemanticsObject*)	child

Definition at line 269 of file SemanticsObject.mm.

                           :(NSInteger)index withChild:(SemanticsObject*)child {
  SemanticsObject* oldChild = _children[index];
  [oldChild privateSetParent:nil];
  [child privateSetParent:self];
  [_children replaceObjectAtIndex:index withObject:child];
}

routeName

- (NSString *) routeName

Definition at line 269 of file SemanticsObject.mm.

                       {
  // Returns the first non-null and non-empty semantic label of a child
  // with an NamesRoute flag. Otherwise returns nil.
  if ([self node].HasFlag(flutter::SemanticsFlags::kNamesRoute)) {
    NSString* newName = [self accessibilityLabel];
    if (newName != nil && [newName length] > 0) {
      return newName;
    }
  }
  if ([self hasChildren]) {
    for (SemanticsObject* child in self.children) {
      NSString* newName = [child routeName];
      if (newName != nil && [newName length] > 0) {
        return newName;
      }
    }
  }
  return nil;
}

search:

- (id) search: (CGPoint)  point

implementation

Definition at line 269 of file SemanticsObject.mm.

            :(CGPoint)point {
  // Search children in hit test order.
  for (SemanticsObject* child in [self childrenInHitTestOrder]) {
    if ([child containsPoint:point]) {
      id childSearchResult = [child search:point];
      if (childSearchResult != nil) {
        return childSearchResult;
      }
    }
  }
  // Check if the current semantic object should be returned.
  if ([self containsPoint:point] && [self isFocusable]) {
    return self.nativeAccessibility;
  }
  return nil;
}

setAccessibilityContainer:

- (void) setAccessibilityContainer: (id)  container

implementation

Definition at line 269 of file SemanticsObject.mm.

                                 :(id)container {
  // Explicit noop.  The containers are calculated lazily in `accessibilityContainer`.
  // See also: https://github.com/flutter/flutter/issues/54366
}

setChildren:

- (void) setChildren: (NSArray<SemanticsObject*>*)  children

implementation

Definition at line 269 of file SemanticsObject.mm.

                   :(NSArray<SemanticsObject*>*)children {
  for (SemanticsObject* child in _children) {
    [child privateSetParent:nil];
  }
  [_children release];
  _children = [[NSMutableArray alloc] initWithArray:children];
  for (SemanticsObject* child in _children) {
    [child privateSetParent:self];
  }
}

setChildrenInHitTestOrder:

- (void) setChildrenInHitTestOrder: (NSArray<SemanticsObject*>*)  childrenInHitTestOrder

implementation

Definition at line 269 of file SemanticsObject.mm.

                                 :(NSArray<SemanticsObject*>*)childrenInHitTestOrder {
  for (SemanticsObject* child in _childrenInHitTestOrder) {
    [child privateSetParent:nil];
  }
  [_childrenInHitTestOrder release];
  _childrenInHitTestOrder = [[NSMutableArray alloc] initWithArray:childrenInHitTestOrder];
  for (SemanticsObject* child in _childrenInHitTestOrder) {
    [child privateSetParent:self];
  }
}

setSemanticsNode:

- (void) setSemanticsNode:

(const flutter::SemanticsNode*)

NS_REQUIRES_SUPER

Updates this semantics object using data from the node argument.

Reimplemented in TextInputSemanticsObject.

Definition at line 269 of file SemanticsObject.mm.

                        :(const flutter::SemanticsNode*)node {
  _node = *node;
}

showOnScreen

- (void) showOnScreen

implementation

Definition at line 269 of file SemanticsObject.mm.

                     {
  [self bridge]->DispatchSemanticsAction([self uid], flutter::SemanticsAction::kShowOnScreen);
}

Property Documentation

bridge

- (WeakPtr<)flutter:

readnonatomicassign

The accessibility bridge that this semantics object is attached to. This object may use the bridge to access contextual application information. A weak pointer is used because the platform view owns the accessibility bridge. If you are referencing this property from an iOS callback, be sure to use isAccessibilityBridgeActive to protect against the case where this node may be orphaned.

Definition at line 51 of file SemanticsObject.h.

children

- (NSArray<SemanticsObject*>*) children

readwritenonatomicstrong

Direct children of this semantics object. Each child's parent property must be equal to this object.

Definition at line 67 of file SemanticsObject.h.

childrenInHitTestOrder

- (NSArray<SemanticsObject*>*) childrenInHitTestOrder

readwritenonatomicstrong

Direct children of this semantics object in hit test order. Each child's parent property must be equal to this object.

Definition at line 73 of file SemanticsObject.h.

hasChildren

- (BOOL) hasChildren

readnonatomicassign

Whether this semantics object has child semantics objects.

Definition at line 61 of file SemanticsObject.h.

nativeAccessibility

- (id) nativeAccessibility

readnonatomicassign

The UIAccessibility that represents this object.

By default, this return self. Subclasses can override to return different objects to represent them. For example, FlutterScrollableSemanticsObject[s] maintain UIScrollView[s] to represent their UIAccessibility[s].

Definition at line 82 of file SemanticsObject.h.

node

- (SemanticsNode) SemanticsObject:

readnonatomicassign

The semantics node used to produce this semantics object.

Definition at line 56 of file SemanticsObject.h.

parent

- (SemanticsObject*) parent

readwritenonatomicassign

The parent of this node in the node tree. Will be nil for the root node and during transient state changes.

Definition at line 41 of file SemanticsObject.h.

uid

- (int32_t) uid

readnonatomicassign

The globally unique identifier for this node.

Definition at line 35 of file SemanticsObject.h.

---

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

• shell/platform/darwin/ios/framework/Source/SemanticsObject.h
• shell/platform/darwin/ios/framework/Source/SemanticsObject.mm