extension.dart 25.3 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:async';
6

7
import 'package:flutter/semantics.dart';
8
import 'package:meta/meta.dart';
9

10
import 'package:flutter/cupertino.dart';
11
import 'package:flutter/foundation.dart';
12
import 'package:flutter/gestures.dart';
13
import 'package:flutter/material.dart';
14
import 'package:flutter/rendering.dart' show RendererBinding, SemanticsHandle;
15
import 'package:flutter/scheduler.dart';
16
import 'package:flutter/services.dart';
17
import 'package:flutter/widgets.dart';
18
import 'package:flutter_test/flutter_test.dart';
19

20
import '../common/diagnostics_tree.dart';
21 22 23
import '../common/error.dart';
import '../common/find.dart';
import '../common/frame_sync.dart';
24
import '../common/geometry.dart';
25 26
import '../common/gesture.dart';
import '../common/health.dart';
27
import '../common/layer_tree.dart';
28 29 30 31
import '../common/message.dart';
import '../common/render_tree.dart';
import '../common/request_data.dart';
import '../common/semantics.dart';
32
import '../common/text.dart';
33 34
import '../common/wait.dart';
import 'wait_conditions.dart';
35

36 37
const String _extensionMethodName = 'driver';
const String _extensionMethod = 'ext.flutter.$_extensionMethodName';
38

39 40 41 42
/// Signature for the handler passed to [enableFlutterDriverExtension].
///
/// Messages are described in string form and should return a [Future] which
/// eventually completes to a string response.
43
typedef DataHandler = Future<String> Function(String message);
44

45
class _DriverBinding extends BindingBase with ServicesBinding, SchedulerBinding, GestureBinding, PaintingBinding, SemanticsBinding, RendererBinding, WidgetsBinding {
46
  _DriverBinding(this._handler, this._silenceErrors);
47 48

  final DataHandler _handler;
49
  final bool _silenceErrors;
50

51 52 53
  @override
  void initServiceExtensions() {
    super.initServiceExtensions();
54
    final FlutterDriverExtension extension = FlutterDriverExtension(_handler, _silenceErrors);
55 56
    registerServiceExtension(
      name: _extensionMethodName,
57
      callback: extension.call,
58 59
    );
  }
60 61 62 63 64

  @override
  BinaryMessenger createBinaryMessenger() {
    return TestDefaultBinaryMessenger(super.createBinaryMessenger());
  }
65
}
66 67 68 69 70 71 72 73

/// Enables Flutter Driver VM service extension.
///
/// This extension is required for tests that use `package:flutter_driver` to
/// drive applications from a separate process.
///
/// Call this function prior to running your application, e.g. before you call
/// `runApp`.
74 75 76
///
/// Optionally you can pass a [DataHandler] callback. It will be called if the
/// test calls [FlutterDriver.requestData].
77
///
Kent Boogaart's avatar
Kent Boogaart committed
78
/// `silenceErrors` will prevent exceptions from being logged. This is useful
79
/// for tests where exceptions are expected. Defaults to false. Any errors
80
/// will still be returned in the `response` field of the result JSON along
81 82
/// with an `isError` boolean.
void enableFlutterDriverExtension({ DataHandler handler, bool silenceErrors = false }) {
83
  assert(WidgetsBinding.instance == null);
84
  _DriverBinding(handler, silenceErrors);
85
  assert(WidgetsBinding.instance is _DriverBinding);
86 87
}

88
/// Signature for functions that handle a command and return a result.
89
typedef CommandHandlerCallback = Future<Result> Function(Command c);
90

91
/// Signature for functions that deserialize a JSON map to a command object.
92
typedef CommandDeserializerCallback = Command Function(Map<String, String> params);
93

94 95
/// Signature for functions that run the given finder and return the [Element]
/// found, if any, or null otherwise.
96
typedef FinderConstructor = Finder Function(SerializableFinder finder);
97

98 99 100 101 102
/// The class that manages communication between a Flutter Driver test and the
/// application being remote-controlled, on the application side.
///
/// This is not normally used directly. It is instantiated automatically when
/// calling [enableFlutterDriverExtension].
103 104
@visibleForTesting
class FlutterDriverExtension {
105
  /// Creates an object to manage a Flutter Driver connection.
106
  FlutterDriverExtension(this._requestDataHandler, this._silenceErrors) {
107 108
    _testTextInput.register();

109
    _commandHandlers.addAll(<String, CommandHandlerCallback>{
110
      'get_health': _getHealth,
111
      'get_layer_tree': _getLayerTree,
112
      'get_render_tree': _getRenderTree,
113
      'enter_text': _enterText,
114
      'get_text': _getText,
115
      'request_data': _requestData,
116 117
      'scroll': _scroll,
      'scrollIntoView': _scrollIntoView,
118 119
      'set_frame_sync': _setFrameSync,
      'set_semantics': _setSemantics,
120
      'set_text_entry_emulation': _setTextEntryEmulation,
121
      'tap': _tap,
122
      'waitFor': _waitFor,
123
      'waitForAbsent': _waitForAbsent,
124 125 126 127
      'waitForCondition': _waitForCondition,
      'waitUntilNoTransientCallbacks': _waitUntilNoTransientCallbacks, // ignore: deprecated_member_use_from_same_package
      'waitUntilNoPendingFrame': _waitUntilNoPendingFrame, // ignore: deprecated_member_use_from_same_package
      'waitUntilFirstFrameRasterized': _waitUntilFirstFrameRasterized, // ignore: deprecated_member_use_from_same_package
128
      'get_semantics_id': _getSemanticsId,
129
      'get_offset': _getOffset,
130
      'get_diagnostics_tree': _getDiagnosticsTree,
131
    });
132

133
    _commandDeserializers.addAll(<String, CommandDeserializerCallback>{
134
      'get_health': (Map<String, String> params) => GetHealth.deserialize(params),
135
      'get_layer_tree': (Map<String, String> params) => GetLayerTree.deserialize(params),
136 137 138 139 140 141 142 143 144 145 146 147
      'get_render_tree': (Map<String, String> params) => GetRenderTree.deserialize(params),
      'enter_text': (Map<String, String> params) => EnterText.deserialize(params),
      'get_text': (Map<String, String> params) => GetText.deserialize(params),
      'request_data': (Map<String, String> params) => RequestData.deserialize(params),
      'scroll': (Map<String, String> params) => Scroll.deserialize(params),
      'scrollIntoView': (Map<String, String> params) => ScrollIntoView.deserialize(params),
      'set_frame_sync': (Map<String, String> params) => SetFrameSync.deserialize(params),
      'set_semantics': (Map<String, String> params) => SetSemantics.deserialize(params),
      'set_text_entry_emulation': (Map<String, String> params) => SetTextEntryEmulation.deserialize(params),
      'tap': (Map<String, String> params) => Tap.deserialize(params),
      'waitFor': (Map<String, String> params) => WaitFor.deserialize(params),
      'waitForAbsent': (Map<String, String> params) => WaitForAbsent.deserialize(params),
148 149 150 151
      'waitForCondition': (Map<String, String> params) => WaitForCondition.deserialize(params),
      'waitUntilNoTransientCallbacks': (Map<String, String> params) => WaitUntilNoTransientCallbacks.deserialize(params), // ignore: deprecated_member_use_from_same_package
      'waitUntilNoPendingFrame': (Map<String, String> params) => WaitUntilNoPendingFrame.deserialize(params), // ignore: deprecated_member_use_from_same_package
      'waitUntilFirstFrameRasterized': (Map<String, String> params) => WaitUntilFirstFrameRasterized.deserialize(params), // ignore: deprecated_member_use_from_same_package
152
      'get_semantics_id': (Map<String, String> params) => GetSemanticsId.deserialize(params),
153
      'get_offset': (Map<String, String> params) => GetOffset.deserialize(params),
154
      'get_diagnostics_tree': (Map<String, String> params) => GetDiagnosticsTree.deserialize(params),
155
    });
156

157
    _finders.addAll(<String, FinderConstructor>{
158 159 160 161 162
      'ByText': (SerializableFinder finder) => _createByTextFinder(finder as ByText),
      'ByTooltipMessage': (SerializableFinder finder) => _createByTooltipMessageFinder(finder as ByTooltipMessage),
      'BySemanticsLabel': (SerializableFinder finder) => _createBySemanticsLabelFinder(finder as BySemanticsLabel),
      'ByValueKey': (SerializableFinder finder) => _createByValueKeyFinder(finder as ByValueKey),
      'ByType': (SerializableFinder finder) => _createByTypeFinder(finder as ByType),
163
      'PageBack': (SerializableFinder finder) => _createPageBackFinder(),
164 165
      'Ancestor': (SerializableFinder finder) => _createAncestorFinder(finder as Ancestor),
      'Descendant': (SerializableFinder finder) => _createDescendantFinder(finder as Descendant),
166
    });
167 168
  }

169 170
  final TestTextInput _testTextInput = TestTextInput();

171
  final DataHandler _requestDataHandler;
172
  final bool _silenceErrors;
173

174 175 176
  void _log(String message) {
    driverLog('FlutterDriverExtension', message);
  }
177

178
  final WidgetController _prober = LiveWidgetController(WidgetsBinding.instance);
179 180
  final Map<String, CommandHandlerCallback> _commandHandlers = <String, CommandHandlerCallback>{};
  final Map<String, CommandDeserializerCallback> _commandDeserializers = <String, CommandDeserializerCallback>{};
181
  final Map<String, FinderConstructor> _finders = <String, FinderConstructor>{};
182

183 184 185 186
  /// With [_frameSync] enabled, Flutter Driver will wait to perform an action
  /// until there are no pending frames in the app under test.
  bool _frameSync = true;

187 188 189 190 191 192 193 194 195 196
  /// Processes a driver command configured by [params] and returns a result
  /// as an arbitrary JSON object.
  ///
  /// [params] must contain key "command" whose value is a string that
  /// identifies the kind of the command and its corresponding
  /// [CommandDeserializerCallback]. Other keys and values are specific to the
  /// concrete implementation of [Command] and [CommandDeserializerCallback].
  ///
  /// The returned JSON is command specific. Generally the caller deserializes
  /// the result into a subclass of [Result], but that's not strictly required.
197
  @visibleForTesting
198
  Future<Map<String, dynamic>> call(Map<String, String> params) async {
199
    final String commandKind = params['command'];
200
    try {
201 202
      final CommandHandlerCallback commandHandler = _commandHandlers[commandKind];
      final CommandDeserializerCallback commandDeserializer =
203
          _commandDeserializers[commandKind];
204 205
      if (commandHandler == null || commandDeserializer == null)
        throw 'Extension $_extensionMethod does not support command $commandKind';
206
      final Command command = commandDeserializer(params);
207 208
      assert(WidgetsBinding.instance.isRootWidgetAttached || !command.requiresRootWidgetAttached,
          'No root widget is attached; have you remembered to call runApp()?');
209 210 211 212
      Future<Result> responseFuture = commandHandler(command);
      if (command.timeout != null)
        responseFuture = responseFuture.timeout(command.timeout);
      final Result response = await responseFuture;
213
      return _makeResponse(response?.toJson());
214
    } on TimeoutException catch (error, stackTrace) {
215 216 217
      final String message = 'Timeout while executing $commandKind: $error\n$stackTrace';
      _log(message);
      return _makeResponse(message, isError: true);
218
    } catch (error, stackTrace) {
219
      final String message = 'Uncaught extension error while executing $commandKind: $error\n$stackTrace';
220
      if (!_silenceErrors)
221 222
        _log(message);
      return _makeResponse(message, isError: true);
223 224 225
    }
  }

226
  Map<String, dynamic> _makeResponse(dynamic response, { bool isError = false }) {
227 228 229 230 231 232
    return <String, dynamic>{
      'isError': isError,
      'response': response,
    };
  }

233
  Future<Health> _getHealth(Command command) async => const Health(HealthStatus.ok);
234

235 236 237 238
  Future<LayerTree> _getLayerTree(Command command) async {
    return LayerTree(RendererBinding.instance?.renderView?.debugLayer?.toStringDeep());
  }

239
  Future<RenderTree> _getRenderTree(Command command) async {
240
    return RenderTree(RendererBinding.instance?.renderView?.toStringDeep());
241 242
  }

243
  // This can be used to wait for the first frame being rasterized during app launch.
244 245 246 247
  @Deprecated(
    'This method has been deprecated in favor of _waitForCondition. '
    'This feature was deprecated after v1.9.3.'
  )
248 249 250 251 252
  Future<Result> _waitUntilFirstFrameRasterized(Command command) async {
    await WidgetsBinding.instance.waitUntilFirstFrameRasterized;
    return null;
  }

253
  // Waits until at the end of a frame the provided [condition] is [true].
254
  Future<void> _waitUntilFrame(bool condition(), [ Completer<void> completer ]) {
255
    completer ??= Completer<void>();
256 257 258 259 260 261 262 263 264 265
    if (!condition()) {
      SchedulerBinding.instance.addPostFrameCallback((Duration timestamp) {
        _waitUntilFrame(condition, completer);
      });
    } else {
      completer.complete();
    }
    return completer.future;
  }

266
  /// Runs `finder` repeatedly until it finds one or more [Element]s.
267 268 269
  Future<Finder> _waitForElement(Finder finder) async {
    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);
270

271
    await _waitUntilFrame(() => finder.evaluate().isNotEmpty);
272 273 274 275 276

    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

    return finder;
277 278
  }

279 280 281 282 283
  /// Runs `finder` repeatedly until it finds zero [Element]s.
  Future<Finder> _waitForAbsentElement(Finder finder) async {
    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

284
    await _waitUntilFrame(() => finder.evaluate().isEmpty);
285 286 287 288 289 290 291

    if (_frameSync)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);

    return finder;
  }

292 293
  Finder _createByTextFinder(ByText arguments) {
    return find.text(arguments.text);
294 295
  }

296 297
  Finder _createByTooltipMessageFinder(ByTooltipMessage arguments) {
    return find.byElementPredicate((Element element) {
298
      final Widget widget = element.widget;
299 300 301
      if (widget is Tooltip)
        return widget.message == arguments.text;
      return false;
302
    }, description: 'widget with text tooltip "${arguments.text}"');
303 304
  }

305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
  Finder _createBySemanticsLabelFinder(BySemanticsLabel arguments) {
    return find.byElementPredicate((Element element) {
      if (element is! RenderObjectElement) {
        return false;
      }
      final String semanticsLabel = element.renderObject?.debugSemantics?.label;
      if (semanticsLabel == null) {
        return false;
      }
      final Pattern label = arguments.label;
      return label is RegExp
          ? label.hasMatch(semanticsLabel)
          : label == semanticsLabel;
    }, description: 'widget with semantic label "${arguments.label}"');
  }

321
  Finder _createByValueKeyFinder(ByValueKey arguments) {
322 323
    switch (arguments.keyValueType) {
      case 'int':
324
        return find.byKey(ValueKey<int>(arguments.keyValue as int));
325
      case 'String':
326
        return find.byKey(ValueKey<String>(arguments.keyValue as String));
327 328 329
      default:
        throw 'Unsupported ByValueKey type: ${arguments.keyValueType}';
    }
330 331
  }

332 333 334 335 336 337
  Finder _createByTypeFinder(ByType arguments) {
    return find.byElementPredicate((Element element) {
      return element.widget.runtimeType.toString() == arguments.type;
    }, description: 'widget with runtimeType "${arguments.type}"');
  }

338 339 340 341 342 343 344 345 346 347 348
  Finder _createPageBackFinder() {
    return find.byElementPredicate((Element element) {
      final Widget widget = element.widget;
      if (widget is Tooltip)
        return widget.message == 'Back';
      if (widget is CupertinoNavigationBarBackButton)
        return true;
      return false;
    }, description: 'Material or Cupertino back button');
  }

349
  Finder _createAncestorFinder(Ancestor arguments) {
350
    final Finder finder = find.ancestor(
351 352 353 354
      of: _createFinder(arguments.of),
      matching: _createFinder(arguments.matching),
      matchRoot: arguments.matchRoot,
    );
355
    return arguments.firstMatchOnly ? finder.first : finder;
356 357 358
  }

  Finder _createDescendantFinder(Descendant arguments) {
359
    final Finder finder = find.descendant(
360 361 362 363
      of: _createFinder(arguments.of),
      matching: _createFinder(arguments.matching),
      matchRoot: arguments.matchRoot,
    );
364
    return arguments.firstMatchOnly ? finder.first : finder;
365 366
  }

367
  Finder _createFinder(SerializableFinder finder) {
368
    final FinderConstructor constructor = _finders[finder.finderType];
369

370
    if (constructor == null)
371 372
      throw 'Unsupported finder type: ${finder.finderType}';

373
    return constructor(finder);
374 375
  }

376
  Future<TapResult> _tap(Command command) async {
377
    final Tap tapCommand = command as Tap;
378 379 380 381
    final Finder computedFinder = await _waitForElement(
      _createFinder(tapCommand.finder).hitTestable()
    );
    await _prober.tap(computedFinder);
382
    return const TapResult();
383 384
  }

385
  Future<WaitForResult> _waitFor(Command command) async {
386
    final WaitFor waitForCommand = command as WaitFor;
387
    await _waitForElement(_createFinder(waitForCommand.finder));
388
    return const WaitForResult();
389 390
  }

391
  Future<WaitForAbsentResult> _waitForAbsent(Command command) async {
392
    final WaitForAbsent waitForAbsentCommand = command as WaitForAbsent;
393
    await _waitForAbsentElement(_createFinder(waitForAbsentCommand.finder));
394
    return const WaitForAbsentResult();
395 396
  }

397 398
  Future<Result> _waitForCondition(Command command) async {
    assert(command != null);
399
    final WaitForCondition waitForConditionCommand = command as WaitForCondition;
400 401 402 403 404
    final WaitCondition condition = deserializeCondition(waitForConditionCommand.condition);
    await condition.wait();
    return null;
  }

405 406 407 408
  @Deprecated(
    'This method has been deprecated in favor of _waitForCondition. '
    'This feature was deprecated after v1.9.3.'
  )
409
  Future<Result> _waitUntilNoTransientCallbacks(Command command) async {
410 411
    if (SchedulerBinding.instance.transientCallbackCount != 0)
      await _waitUntilFrame(() => SchedulerBinding.instance.transientCallbackCount == 0);
412
    return null;
413 414
  }

415
  /// Returns a future that waits until no pending frame is scheduled (frame is synced).
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
  ///
  /// Specifically, it checks:
  /// * Whether the count of transient callbacks is zero.
  /// * Whether there's no pending request for scheduling a new frame.
  ///
  /// We consider the frame is synced when both conditions are met.
  ///
  /// This method relies on a Flutter Driver mechanism called "frame sync",
  /// which waits for transient animations to finish. Persistent animations will
  /// cause this to wait forever.
  ///
  /// If a test needs to interact with the app while animations are running, it
  /// should avoid this method and instead disable the frame sync using
  /// `set_frame_sync` method. See [FlutterDriver.runUnsynchronized] for more
  /// details on how to do this. Note, disabling frame sync will require the
  /// test author to use some other method to avoid flakiness.
432 433
  ///
  /// This method has been deprecated in favor of [_waitForCondition].
434 435 436 437
  @Deprecated(
    'This method has been deprecated in favor of _waitForCondition. '
    'This feature was deprecated after v1.9.3.'
  )
438
  Future<Result> _waitUntilNoPendingFrame(Command command) async {
439 440 441 442 443 444 445
    await _waitUntilFrame(() {
      return SchedulerBinding.instance.transientCallbackCount == 0
          && !SchedulerBinding.instance.hasScheduledFrame;
    });
    return null;
  }

446
  Future<GetSemanticsIdResult> _getSemanticsId(Command command) async {
447
    final GetSemanticsId semanticsCommand = command as GetSemanticsId;
448
    final Finder target = await _waitForElement(_createFinder(semanticsCommand.finder));
449 450 451 452 453
    final Iterable<Element> elements = target.evaluate();
    if (elements.length > 1) {
      throw StateError('Found more than one element with the same ID: $elements');
    }
    final Element element = elements.single;
454 455 456 457
    RenderObject renderObject = element.renderObject;
    SemanticsNode node;
    while (renderObject != null && node == null) {
      node = renderObject.debugSemantics;
458
      renderObject = renderObject.parent as RenderObject;
459 460
    }
    if (node == null)
461 462
      throw StateError('No semantics data found');
    return GetSemanticsIdResult(node.id);
463 464
  }

465
  Future<GetOffsetResult> _getOffset(Command command) async {
466
    final GetOffset getOffsetCommand = command as GetOffset;
467 468
    final Finder finder = await _waitForElement(_createFinder(getOffsetCommand.finder));
    final Element element = finder.evaluate().single;
469
    final RenderBox box = element.renderObject as RenderBox;
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
    Offset localPoint;
    switch (getOffsetCommand.offsetType) {
      case OffsetType.topLeft:
        localPoint = Offset.zero;
        break;
      case OffsetType.topRight:
        localPoint = box.size.topRight(Offset.zero);
        break;
      case OffsetType.bottomLeft:
        localPoint = box.size.bottomLeft(Offset.zero);
        break;
      case OffsetType.bottomRight:
        localPoint = box.size.bottomRight(Offset.zero);
        break;
      case OffsetType.center:
        localPoint = box.size.center(Offset.zero);
        break;
    }
    final Offset globalPoint = box.localToGlobal(localPoint);
    return GetOffsetResult(dx: globalPoint.dx, dy: globalPoint.dy);
  }

492
  Future<DiagnosticsTreeResult> _getDiagnosticsTree(Command command) async {
493
    final GetDiagnosticsTree diagnosticsCommand = command as GetDiagnosticsTree;
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
    final Finder finder = await _waitForElement(_createFinder(diagnosticsCommand.finder));
    final Element element = finder.evaluate().single;
    DiagnosticsNode diagnosticsNode;
    switch (diagnosticsCommand.diagnosticsType) {
      case DiagnosticsType.renderObject:
        diagnosticsNode = element.renderObject.toDiagnosticsNode();
        break;
      case DiagnosticsType.widget:
        diagnosticsNode = element.toDiagnosticsNode();
        break;
    }
    return DiagnosticsTreeResult(diagnosticsNode.toJsonMap(DiagnosticsSerializationDelegate(
      subtreeDepth: diagnosticsCommand.subtreeDepth,
      includeProperties: diagnosticsCommand.includeProperties,
    )));
  }

511
  Future<ScrollResult> _scroll(Command command) async {
512
    final Scroll scrollCommand = command as Scroll;
513
    final Finder target = await _waitForElement(_createFinder(scrollCommand.finder));
514
    final int totalMoves = scrollCommand.duration.inMicroseconds * scrollCommand.frequency ~/ Duration.microsecondsPerSecond;
515
    final Offset delta = Offset(scrollCommand.dx, scrollCommand.dy) / totalMoves.toDouble();
516
    final Duration pause = scrollCommand.duration ~/ totalMoves;
517 518
    final Offset startLocation = _prober.getCenter(target);
    Offset currentLocation = startLocation;
519 520
    final TestPointer pointer = TestPointer(1);
    final HitTestResult hitTest = HitTestResult();
521

522 523
    _prober.binding.hitTest(hitTest, startLocation);
    _prober.binding.dispatchEvent(pointer.down(startLocation), hitTest);
524
    await Future<void>.value(); // so that down and move don't happen in the same microtask
525
    for (int moves = 0; moves < totalMoves; moves += 1) {
526
      currentLocation = currentLocation + delta;
527
      _prober.binding.dispatchEvent(pointer.move(currentLocation), hitTest);
528
      await Future<void>.delayed(pause);
529
    }
530
    _prober.binding.dispatchEvent(pointer.up(), hitTest);
531

532
    return const ScrollResult();
533 534
  }

535
  Future<ScrollResult> _scrollIntoView(Command command) async {
536
    final ScrollIntoView scrollIntoViewCommand = command as ScrollIntoView;
537
    final Finder target = await _waitForElement(_createFinder(scrollIntoViewCommand.finder));
Adam Barth's avatar
Adam Barth committed
538
    await Scrollable.ensureVisible(target.evaluate().single, duration: const Duration(milliseconds: 100), alignment: scrollIntoViewCommand.alignment ?? 0.0);
539
    return const ScrollResult();
540 541
  }

542
  Future<GetTextResult> _getText(Command command) async {
543
    final GetText getTextCommand = command as GetText;
544
    final Finder target = await _waitForElement(_createFinder(getTextCommand.finder));
545
    // TODO(yjbanov): support more ways to read text
546
    final Text text = target.evaluate().single.widget as Text;
547
    return GetTextResult(text.data);
548
  }
549

550
  Future<SetTextEntryEmulationResult> _setTextEntryEmulation(Command command) async {
551
    final SetTextEntryEmulation setTextEntryEmulationCommand = command as SetTextEntryEmulation;
552 553 554 555 556
    if (setTextEntryEmulationCommand.enabled) {
      _testTextInput.register();
    } else {
      _testTextInput.unregister();
    }
557
    return const SetTextEntryEmulationResult();
558 559
  }

560
  Future<EnterTextResult> _enterText(Command command) async {
561 562 563 564
    if (!_testTextInput.isRegistered) {
      throw 'Unable to fulfill `FlutterDriver.enterText`. Text emulation is '
            'disabled. You can enable it using `FlutterDriver.setTextEntryEmulation`.';
    }
565
    final EnterText enterTextCommand = command as EnterText;
566
    _testTextInput.enterText(enterTextCommand.text);
567
    return const EnterTextResult();
568 569
  }

570
  Future<RequestDataResult> _requestData(Command command) async {
571
    final RequestData requestDataCommand = command as RequestData;
572
    return RequestDataResult(_requestDataHandler == null ? 'No requestData Extension registered' : await _requestDataHandler(requestDataCommand.message));
573 574
  }

575
  Future<SetFrameSyncResult> _setFrameSync(Command command) async {
576
    final SetFrameSync setFrameSyncCommand = command as SetFrameSync;
577
    _frameSync = setFrameSyncCommand.enabled;
578
    return const SetFrameSyncResult();
579
  }
580 581 582 583 584

  SemanticsHandle _semantics;
  bool get _semanticsIsEnabled => RendererBinding.instance.pipelineOwner.semanticsOwner != null;

  Future<SetSemanticsResult> _setSemantics(Command command) async {
585
    final SetSemantics setSemanticsCommand = command as SetSemantics;
586 587 588 589 590
    final bool semanticsWasEnabled = _semanticsIsEnabled;
    if (setSemanticsCommand.enabled && _semantics == null) {
      _semantics = RendererBinding.instance.pipelineOwner.ensureSemantics();
      if (!semanticsWasEnabled) {
        // wait for the first frame where semantics is enabled.
591
        final Completer<void> completer = Completer<void>();
592 593 594 595 596 597 598 599 600
        SchedulerBinding.instance.addPostFrameCallback((Duration d) {
          completer.complete();
        });
        await completer.future;
      }
    } else if (!setSemanticsCommand.enabled && _semantics != null) {
      _semantics.dispose();
      _semantics = null;
    }
601
    return SetSemanticsResult(semanticsWasEnabled != _semanticsIsEnabled);
602
  }
603
}