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

5 6
// @dart = 2.8

7
import 'package:flutter/foundation.dart';
8
import 'package:flutter/gestures.dart';
9 10 11
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';

12 13
import 'basic.dart';
import 'debug.dart';
14 15
import 'focus_manager.dart';
import 'focus_scope.dart';
16 17 18 19
import 'framework.dart';

/// Embeds an Android view in the Widget hierarchy.
///
20 21
/// Requires Android API level 20 or greater.
///
22 23 24 25 26 27
/// Embedding Android views is an expensive operation and should be avoided when a Flutter
/// equivalent is possible.
///
/// The embedded Android view is painted just like any other Flutter widget and transformations
/// apply to it as well.
///
28 29
/// {@template flutter.widgets.platformViews.layout}
/// The widget fills all available space, the parent of this object must provide bounded layout
30
/// constraints.
31
/// {@endtemplate}
32
///
33
/// {@template flutter.widgets.platformViews.gestures}
34
/// The widget participates in Flutter's gesture arenas, and dispatches touch events to the
35 36 37
/// platform view iff it won the arena. Specific gestures that should be dispatched to the platform
/// view can be specified in the `gestureRecognizers` constructor parameter. If
/// the set of gesture recognizers is empty, a gesture will be dispatched to the platform
38
/// view iff it was not claimed by any other gesture recognizer.
39
/// {@endtemplate}
40
///
41 42 43 44 45 46 47
/// The Android view object is created using a [PlatformViewFactory](/javadoc/io/flutter/plugin/platform/PlatformViewFactory.html).
/// Plugins can register platform view factories with [PlatformViewRegistry#registerViewFactory](/javadoc/io/flutter/plugin/platform/PlatformViewRegistry.html#registerViewFactory-java.lang.String-io.flutter.plugin.platform.PlatformViewFactory-).
///
/// Registration is typically done in the plugin's registerWith method, e.g:
///
/// ```java
///   public static void registerWith(Registrar registrar) {
48
///     registrar.platformViewRegistry().registerViewFactory("webview", WebViewFactory(registrar.messenger()));
49 50 51
///   }
/// ```
///
52 53
/// {@template flutter.widgets.platformViews.lifetime}
/// The platform view's lifetime is the same as the lifetime of the [State] object for this widget.
54 55
/// When the [State] is disposed the platform view (and auxiliary resources) are lazily
/// released (some resources are immediately released and some by platform garbage collector).
56
/// A stateful widget's state is disposed when the widget is removed from the tree or when it is
57 58
/// moved within the tree. If the stateful widget has a key and it's only moved relative to its siblings,
/// or it has a [GlobalKey] and it's moved within the tree, it will not be disposed.
59
/// {@endtemplate}
60 61 62
class AndroidView extends StatefulWidget {
  /// Creates a widget that embeds an Android view.
  ///
63
  /// {@template flutter.widgets.platformViews.constructorParams}
64
  /// The `viewType` and `hitTestBehavior` parameters must not be null.
65
  /// If `creationParams` is not null then `creationParamsCodec` must not be null.
66
  /// {@endtemplate}
67
  const AndroidView({
68 69
    Key key,
    @required this.viewType,
70 71
    this.onPlatformViewCreated,
    this.hitTestBehavior = PlatformViewHitTestBehavior.opaque,
72
    this.layoutDirection,
73
    this.gestureRecognizers,
74
    this.creationParams,
75
    this.creationParamsCodec,
76
  }) : assert(viewType != null),
77
       assert(hitTestBehavior != null),
78
       assert(creationParams == null || creationParamsCodec != null),
79 80 81
       super(key: key);

  /// The unique identifier for Android view type to be embedded by this widget.
82
  ///
83 84 85
  /// A [PlatformViewFactory](/javadoc/io/flutter/plugin/platform/PlatformViewFactory.html)
  /// for this type must have been registered.
  ///
86 87 88
  /// See also:
  ///
  ///  * [AndroidView] for an example of registering a platform view factory.
89 90
  final String viewType;

91 92
  /// {@template flutter.widgets.platformViews.createdParam}
  /// Callback to invoke after the platform view has been created.
93 94
  ///
  /// May be null.
95
  /// {@endtemplate}
96
  final PlatformViewCreatedCallback onPlatformViewCreated;
97

98
  /// {@template flutter.widgets.platformViews.hittestParam}
99 100 101
  /// How this widget should behave during hit testing.
  ///
  /// This defaults to [PlatformViewHitTestBehavior.opaque].
102
  /// {@endtemplate}
103 104
  final PlatformViewHitTestBehavior hitTestBehavior;

105
  /// {@template flutter.widgets.platformViews.directionParam}
106 107 108
  /// The text direction to use for the embedded view.
  ///
  /// If this is null, the ambient [Directionality] is used instead.
109
  /// {@endtemplate}
110 111
  final TextDirection layoutDirection;

112 113
  /// Which gestures should be forwarded to the Android view.
  ///
114
  /// {@template flutter.widgets.platformViews.gestureRecognizersDescHead}
115 116
  /// The gesture recognizers built by factories in this set participate in the gesture arena for
  /// each pointer that was put down on the widget. If any of these recognizers win the
117
  /// gesture arena, the entire pointer event sequence starting from the pointer down event
118
  /// will be dispatched to the platform view.
119
  ///
120
  /// When null, an empty set of gesture recognizer factories is used, in which case a pointer event sequence
121 122
  /// will only be dispatched to the platform view if no other member of the arena claimed it.
  /// {@endtemplate}
123
  ///
124 125
  /// For example, with the following setup vertical drags will not be dispatched to the Android
  /// view as the vertical drag gesture is claimed by the parent [GestureDetector].
126
  ///
127 128 129 130 131 132 133 134
  /// ```dart
  /// GestureDetector(
  ///   onVerticalDragStart: (DragStartDetails d) {},
  ///   child: AndroidView(
  ///     viewType: 'webview',
  ///   ),
  /// )
  /// ```
135
  ///
136
  /// To get the [AndroidView] to claim the vertical drag gestures we can pass a vertical drag
137
  /// gesture recognizer factory in [gestureRecognizers] e.g:
138
  ///
139 140
  /// ```dart
  /// GestureDetector(
141
  ///   onVerticalDragStart: (DragStartDetails details) {},
142 143 144 145 146
  ///   child: SizedBox(
  ///     width: 200.0,
  ///     height: 100.0,
  ///     child: AndroidView(
  ///       viewType: 'webview',
147 148 149 150 151
  ///       gestureRecognizers: <Factory<OneSequenceGestureRecognizer>>[
  ///         new Factory<OneSequenceGestureRecognizer>(
  ///           () => new EagerGestureRecognizer(),
  ///         ),
  ///       ].toSet(),
152 153 154 155 156
  ///     ),
  ///   ),
  /// )
  /// ```
  ///
157 158
  /// {@template flutter.widgets.platformViews.gestureRecognizersDescFoot}
  /// A platform view can be configured to consume all pointers that were put down in its bounds
159 160 161 162 163 164 165
  /// by passing a factory for an [EagerGestureRecognizer] in [gestureRecognizers].
  /// [EagerGestureRecognizer] is a special gesture recognizer that immediately claims the gesture
  /// after a pointer down event.
  ///
  /// The `gestureRecognizers` property must not contain more than one factory with the same [Factory.type].
  ///
  /// Changing `gestureRecognizers` results in rejection of any active gesture arenas (if the
166 167
  /// platform view is actively participating in an arena).
  /// {@endtemplate}
168 169 170
  // We use OneSequenceGestureRecognizers as they support gesture arena teams.
  // TODO(amirh): get a list of GestureRecognizers here.
  // https://github.com/flutter/flutter/issues/20953
171
  final Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers;
172

173 174 175 176 177 178 179 180 181 182 183 184 185
  /// Passed as the args argument of [PlatformViewFactory#create](/javadoc/io/flutter/plugin/platform/PlatformViewFactory.html#create-android.content.Context-int-java.lang.Object-)
  ///
  /// This can be used by plugins to pass constructor parameters to the embedded Android view.
  final dynamic creationParams;

  /// The codec used to encode `creationParams` before sending it to the
  /// platform side. It should match the codec passed to the constructor of [PlatformViewFactory](/javadoc/io/flutter/plugin/platform/PlatformViewFactory.html#PlatformViewFactory-io.flutter.plugin.common.MessageCodec-).
  ///
  /// This is typically one of: [StandardMessageCodec], [JSONMessageCodec], [StringCodec], or [BinaryCodec].
  ///
  /// This must not be null if [creationParams] is not null.
  final MessageCodec<dynamic> creationParamsCodec;

186
  @override
187 188 189 190
  State<AndroidView> createState() => _AndroidViewState();
}

// TODO(amirh): describe the embedding mechanism.
191
// TODO(ychris): remove the documentation for conic path not supported once https://github.com/flutter/flutter/issues/35062 is resolved.
192 193 194
/// Embeds an iOS view in the Widget hierarchy.
///
/// {@macro flutter.rendering.platformView.preview}
195 196 197 198 199 200
///
/// Embedding iOS views is an expensive operation and should be avoided when a Flutter
/// equivalent is possible.
///
/// {@macro flutter.widgets.platformViews.layout}
///
201 202
/// {@macro flutter.widgets.platformViews.gestures}
///
203
/// {@macro flutter.widgets.platformViews.lifetime}
204 205 206
///
/// Construction of UIViews is done asynchronously, before the UIView is ready this widget paints
/// nothing while maintaining the same layout constraints.
207 208 209
///
/// If a conic path clipping is applied to a UIKitView,
/// a quad path is used to approximate the clip due to limitation of Quartz.
210 211 212 213
class UiKitView extends StatefulWidget {
  /// Creates a widget that embeds an iOS view.
  ///
  /// {@macro flutter.widgets.platformViews.constructorParams}
214
  const UiKitView({
215 216 217 218 219
    Key key,
    @required this.viewType,
    this.onPlatformViewCreated,
    this.hitTestBehavior = PlatformViewHitTestBehavior.opaque,
    this.layoutDirection,
220 221
    this.creationParams,
    this.creationParamsCodec,
222
    this.gestureRecognizers,
223
  }) : assert(viewType != null),
224 225 226
       assert(hitTestBehavior != null),
       assert(creationParams == null || creationParamsCodec != null),
       super(key: key);
227

Chris Bracken's avatar
Chris Bracken committed
228
  // TODO(amirh): reference the iOS API doc once available.
229 230 231 232 233 234 235 236 237 238 239 240 241 242
  /// The unique identifier for iOS view type to be embedded by this widget.
  ///
  /// A PlatformViewFactory for this type must have been registered.
  final String viewType;

  /// {@macro flutter.widgets.platformViews.createdParam}
  final PlatformViewCreatedCallback onPlatformViewCreated;

  /// {@macro flutter.widgets.platformViews.hittestParam}
  final PlatformViewHitTestBehavior hitTestBehavior;

  /// {@macro flutter.widgets.platformViews.directionParam}
  final TextDirection layoutDirection;

243
  /// Passed as the `arguments` argument of [-\[FlutterPlatformViewFactory createWithFrame:viewIdentifier:arguments:\]](/objcdoc/Protocols/FlutterPlatformViewFactory.html#/c:objc(pl)FlutterPlatformViewFactory(im)createWithFrame:viewIdentifier:arguments:)
244
  ///
245
  /// This can be used by plugins to pass constructor parameters to the embedded iOS view.
246 247 248
  final dynamic creationParams;

  /// The codec used to encode `creationParams` before sending it to the
249
  /// platform side. It should match the codec returned by [-\[FlutterPlatformViewFactory createArgsCodec:\]](/objcdoc/Protocols/FlutterPlatformViewFactory.html#/c:objc(pl)FlutterPlatformViewFactory(im)createArgsCodec)
250 251 252 253 254 255
  ///
  /// This is typically one of: [StandardMessageCodec], [JSONMessageCodec], [StringCodec], or [BinaryCodec].
  ///
  /// This must not be null if [creationParams] is not null.
  final MessageCodec<dynamic> creationParamsCodec;

256 257 258 259 260 261
  /// Which gestures should be forwarded to the UIKit view.
  ///
  /// {@macro flutter.widgets.platformViews.gestureRecognizersDescHead}
  ///
  /// For example, with the following setup vertical drags will not be dispatched to the UIKit
  /// view as the vertical drag gesture is claimed by the parent [GestureDetector].
262
  ///
263 264 265 266 267 268 269 270
  /// ```dart
  /// GestureDetector(
  ///   onVerticalDragStart: (DragStartDetails details) {},
  ///   child: UiKitView(
  ///     viewType: 'webview',
  ///   ),
  /// )
  /// ```
271
  ///
272 273
  /// To get the [UiKitView] to claim the vertical drag gestures we can pass a vertical drag
  /// gesture recognizer factory in [gestureRecognizers] e.g:
274
  ///
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
  /// ```dart
  /// GestureDetector(
  ///   onVerticalDragStart: (DragStartDetails details) {},
  ///   child: SizedBox(
  ///     width: 200.0,
  ///     height: 100.0,
  ///     child: UiKitView(
  ///       viewType: 'webview',
  ///       gestureRecognizers: <Factory<OneSequenceGestureRecognizer>>[
  ///         new Factory<OneSequenceGestureRecognizer>(
  ///           () => new EagerGestureRecognizer(),
  ///         ),
  ///       ].toSet(),
  ///     ),
  ///   ),
  /// )
  /// ```
  ///
  /// {@macro flutter.widgets.platformViews.gestureRecognizersDescFoot}
  // We use OneSequenceGestureRecognizers as they support gesture arena teams.
  // TODO(amirh): get a list of GestureRecognizers here.
  // https://github.com/flutter/flutter/issues/20953
  final Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers;

299 300
  @override
  State<UiKitView> createState() => _UiKitViewState();
301 302
}

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
/// Embeds an HTML element in the Widget hierarchy in Flutter Web.
///
/// *NOTE*: This only works in Flutter Web. To embed web content on other
/// platforms, consider using the `flutter_webview` plugin.
///
/// Embedding HTML is an expensive operation and should be avoided when a
/// Flutter equivalent is possible.
///
/// The embedded HTML is painted just like any other Flutter widget and
/// transformations apply to it as well. This widget should only be used in
/// Flutter Web.
///
/// {@macro flutter.widgets.platformViews.layout}
///
/// Due to security restrictions with cross-origin `<iframe>` elements, Flutter
/// cannot dispatch pointer events to an HTML view. If an `<iframe>` is the
/// target of an event, the window containing the `<iframe>` is not notified
/// of the event. In particular, this means that any pointer events which land
/// on an `<iframe>` will not be seen by Flutter, and so the HTML view cannot
/// participate in gesture detection with other widgets.
///
/// The way we enable accessibility on Flutter for web is to have a full-page
/// button which waits for a double tap. Placing this full-page button in front
/// of the scene would cause platform views not to receive pointer events. The
/// tradeoff is that by placing the scene in front of the semantics placeholder
/// will cause platform views to block pointer events from reaching the
/// placeholder. This means that in order to enable accessibility, you must
/// double tap the app *outside of a platform view*. As a consequence, a
/// full-screen platform view will make it impossible to enable accessibility.
/// Make sure that your HTML views are sized no larger than necessary, or you
/// may cause difficulty for users trying to enable accessibility.
///
/// {@macro flutter.widgets.platformViews.lifetime}
class HtmlElementView extends StatelessWidget {
  /// Creates a platform view for Flutter Web.
  ///
  /// `viewType` identifies the type of platform view to create.
  const HtmlElementView({
    Key key,
    @required this.viewType,
  }) : assert(viewType != null),
       assert(kIsWeb, 'HtmlElementView is only available on Flutter Web.'),
       super(key: key);

  /// The unique identifier for the HTML view type to be embedded by this widget.
  ///
  /// A PlatformViewFactory for this type must have been registered.
  final String viewType;

  @override
  Widget build(BuildContext context) {
    return PlatformViewLink(
      viewType: viewType,
      onCreatePlatformView: _createHtmlElementView,
      surfaceFactory: (BuildContext context, PlatformViewController controller) {
        return PlatformViewSurface(
          controller: controller,
          gestureRecognizers: const <Factory<OneSequenceGestureRecognizer>>{},
          hitTestBehavior: PlatformViewHitTestBehavior.opaque,
        );
      },
    );
  }

  /// Creates the controller and kicks off its initialization.
  _HtmlElementViewController _createHtmlElementView(PlatformViewCreationParams params) {
    final _HtmlElementViewController controller = _HtmlElementViewController(params.id, viewType);
    controller._initialize().then((_) { params.onPlatformViewCreated(params.id); });
    return controller;
  }
}

class _HtmlElementViewController extends PlatformViewController {
  _HtmlElementViewController(
    this.viewId,
    this.viewType,
  );

  @override
  final int viewId;

  /// The unique identifier for the HTML view type to be embedded by this widget.
  ///
  /// A PlatformViewFactory for this type must have been registered.
  final String viewType;

  bool _initialized = false;

  Future<void> _initialize() async {
    final Map<String, dynamic> args = <String, dynamic>{
      'id': viewId,
      'viewType': viewType,
    };
    await SystemChannels.platform_views.invokeMethod<void>('create', args);
    _initialized = true;
  }

  @override
401
  Future<void> clearFocus() async {
402 403 404 405 406
    // Currently this does nothing on Flutter Web.
    // TODO(het): Implement this. See https://github.com/flutter/flutter/issues/39496
  }

  @override
407
  Future<void> dispatchPointerEvent(PointerEvent event) async {
408 409 410 411 412
    // We do not dispatch pointer events to HTML views because they may contain
    // cross-origin iframes, which only accept user-generated events.
  }

  @override
413
  Future<void> dispose() async {
414
    if (_initialized) {
415
      await SystemChannels.platform_views.invokeMethod<void>('dispose', viewId);
416 417 418 419
    }
  }
}

420 421 422
class _AndroidViewState extends State<AndroidView> {
  int _id;
  AndroidViewController _controller;
423 424
  TextDirection _layoutDirection;
  bool _initialized = false;
425
  FocusNode _focusNode;
426

427
  static final Set<Factory<OneSequenceGestureRecognizer>> _emptyRecognizersSet =
428
    <Factory<OneSequenceGestureRecognizer>>{};
429

430 431
  @override
  Widget build(BuildContext context) {
432 433
    return Focus(
      focusNode: _focusNode,
434
      onFocusChange: _onFocusChange,
435
      child: _AndroidPlatformView(
436
        controller: _controller,
437
        hitTestBehavior: widget.hitTestBehavior,
438
        gestureRecognizers: widget.gestureRecognizers ?? _emptyRecognizersSet,
439
      ),
440
    );
441 442
  }

443 444 445 446 447
  void _initializeOnce() {
    if (_initialized) {
      return;
    }
    _initialized = true;
448
    _createNewAndroidView();
449
    _focusNode = FocusNode(debugLabel: 'AndroidView(id: $_id)');
450 451
  }

452 453 454 455 456 457 458
  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    final TextDirection newLayoutDirection = _findLayoutDirection();
    final bool didChangeLayoutDirection = _layoutDirection != newLayoutDirection;
    _layoutDirection = newLayoutDirection;

459
    _initializeOnce();
460 461 462 463 464 465 466
    if (didChangeLayoutDirection) {
      // The native view will update asynchronously, in the meantime we don't want
      // to block the framework. (so this is intentionally not awaiting).
      _controller.setLayoutDirection(_layoutDirection);
    }
  }

467 468 469
  @override
  void didUpdateWidget(AndroidView oldWidget) {
    super.didUpdateWidget(oldWidget);
470 471 472 473 474 475 476 477

    final TextDirection newLayoutDirection = _findLayoutDirection();
    final bool didChangeLayoutDirection = _layoutDirection != newLayoutDirection;
    _layoutDirection = newLayoutDirection;

    if (widget.viewType != oldWidget.viewType) {
      _controller.dispose();
      _createNewAndroidView();
478
      return;
479 480 481 482 483 484 485 486 487 488
    }

    if (didChangeLayoutDirection) {
      _controller.setLayoutDirection(_layoutDirection);
    }
  }

  TextDirection _findLayoutDirection() {
    assert(widget.layoutDirection != null || debugCheckHasDirectionality(context));
    return widget.layoutDirection ?? Directionality.of(context);
489 490 491 492 493 494 495 496 497 498 499
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  void _createNewAndroidView() {
    _id = platformViewsRegistry.getNextPlatformViewId();
    _controller = PlatformViewsService.initAndroidView(
500 501 502 503 504
      id: _id,
      viewType: widget.viewType,
      layoutDirection: _layoutDirection,
      creationParams: widget.creationParams,
      creationParamsCodec: widget.creationParamsCodec,
505 506
      onFocus: () {
        _focusNode.requestFocus();
507
      },
508
    );
509 510 511
    if (widget.onPlatformViewCreated != null) {
      _controller.addOnPlatformViewCreatedListener(widget.onPlatformViewCreated);
    }
512
  }
513 514 515 516 517 518 519

  void _onFocusChange(bool isFocused) {
    if (!_controller.isCreated) {
      return;
    }
    if (!isFocused) {
      _controller.clearFocus().catchError((dynamic e) {
520 521 522 523 524 525 526 527 528
        if (e is MissingPluginException) {
          // We land the framework part of Android platform views keyboard
          // support before the engine part. There will be a commit range where
          // clearFocus isn't implemented in the engine. When that happens we
          // just swallow the error here. Once the engine part is rolled to the
          // framework I'll remove this.
          // TODO(amirh): remove this once the engine's clearFocus is rolled.
          return;
        }
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
      });
      return;
    }
    SystemChannels.textInput.invokeMethod<void>(
      'TextInput.setPlatformViewClient',
      _id,
    ).catchError((dynamic e) {
      if (e is MissingPluginException) {
        // We land the framework part of Android platform views keyboard
        // support before the engine part. There will be a commit range where
        // setPlatformViewClient isn't implemented in the engine. When that
        // happens we just swallow the error here. Once the engine part is
        // rolled to the framework I'll remove this.
        // TODO(amirh): remove this once the engine's clearFocus is rolled.
        return;
      }
    });
  }
547 548
}

549 550 551 552 553 554
class _UiKitViewState extends State<UiKitView> {
  UiKitViewController _controller;
  TextDirection _layoutDirection;
  bool _initialized = false;

  static final Set<Factory<OneSequenceGestureRecognizer>> _emptyRecognizersSet =
555
    <Factory<OneSequenceGestureRecognizer>>{};
556 557 558 559 560 561 562

  @override
  Widget build(BuildContext context) {
    if (_controller == null) {
      return const SizedBox.expand();
    }
    return _UiKitPlatformView(
563
      controller: _controller,
564
      hitTestBehavior: widget.hitTestBehavior,
565
      gestureRecognizers: widget.gestureRecognizers ?? _emptyRecognizersSet,
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
    );
  }

  void _initializeOnce() {
    if (_initialized) {
      return;
    }
    _initialized = true;
    _createNewUiKitView();
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    final TextDirection newLayoutDirection = _findLayoutDirection();
    final bool didChangeLayoutDirection = _layoutDirection != newLayoutDirection;
    _layoutDirection = newLayoutDirection;

    _initializeOnce();
    if (didChangeLayoutDirection) {
      // The native view will update asynchronously, in the meantime we don't want
      // to block the framework. (so this is intentionally not awaiting).
      _controller?.setLayoutDirection(_layoutDirection);
    }
  }

  @override
  void didUpdateWidget(UiKitView oldWidget) {
    super.didUpdateWidget(oldWidget);

    final TextDirection newLayoutDirection = _findLayoutDirection();
    final bool didChangeLayoutDirection = _layoutDirection != newLayoutDirection;
    _layoutDirection = newLayoutDirection;

    if (widget.viewType != oldWidget.viewType) {
      _controller?.dispose();
      _createNewUiKitView();
      return;
    }

    if (didChangeLayoutDirection) {
      _controller?.setLayoutDirection(_layoutDirection);
    }
  }

  TextDirection _findLayoutDirection() {
    assert(widget.layoutDirection != null || debugCheckHasDirectionality(context));
    return widget.layoutDirection ?? Directionality.of(context);
  }

  @override
  void dispose() {
    _controller?.dispose();
    super.dispose();
  }

  Future<void> _createNewUiKitView() async {
623
    final int id = platformViewsRegistry.getNextPlatformViewId();
624
    final UiKitViewController controller = await PlatformViewsService.initUiKitView(
625
      id: id,
626 627
      viewType: widget.viewType,
      layoutDirection: _layoutDirection,
628 629
      creationParams: widget.creationParams,
      creationParamsCodec: widget.creationParamsCodec,
630 631 632 633 634 635
    );
    if (!mounted) {
      controller.dispose();
      return;
    }
    if (widget.onPlatformViewCreated != null) {
636
      widget.onPlatformViewCreated(id);
637 638 639 640 641
    }
    setState(() { _controller = controller; });
  }
}

642 643 644 645
class _AndroidPlatformView extends LeafRenderObjectWidget {
  const _AndroidPlatformView({
    Key key,
    @required this.controller,
646
    @required this.hitTestBehavior,
647
    @required this.gestureRecognizers,
648
  }) : assert(controller != null),
649
       assert(hitTestBehavior != null),
650
       assert(gestureRecognizers != null),
651 652 653
       super(key: key);

  final AndroidViewController controller;
654
  final PlatformViewHitTestBehavior hitTestBehavior;
655
  final Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers;
656 657 658

  @override
  RenderObject createRenderObject(BuildContext context) =>
659
      RenderAndroidView(
660 661 662 663
        viewController: controller,
        hitTestBehavior: hitTestBehavior,
        gestureRecognizers: gestureRecognizers,
      );
664 665 666 667

  @override
  void updateRenderObject(BuildContext context, RenderAndroidView renderObject) {
    renderObject.viewController = controller;
668
    renderObject.hitTestBehavior = hitTestBehavior;
669
    renderObject.updateGestureRecognizers(gestureRecognizers);
670 671
  }
}
672 673 674 675

class _UiKitPlatformView extends LeafRenderObjectWidget {
  const _UiKitPlatformView({
    Key key,
676
    @required this.controller,
677
    @required this.hitTestBehavior,
678 679
    @required this.gestureRecognizers,
  }) : assert(controller != null),
680
       assert(hitTestBehavior != null),
681
       assert(gestureRecognizers != null),
682 683
       super(key: key);

684
  final UiKitViewController controller;
685
  final PlatformViewHitTestBehavior hitTestBehavior;
686
  final Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers;
687 688 689 690

  @override
  RenderObject createRenderObject(BuildContext context) {
    return RenderUiKitView(
691
      viewController: controller,
692
      hitTestBehavior: hitTestBehavior,
693
      gestureRecognizers: gestureRecognizers,
694 695 696 697 698
    );
  }

  @override
  void updateRenderObject(BuildContext context, RenderUiKitView renderObject) {
699
    renderObject.viewController = controller;
700
    renderObject.hitTestBehavior = hitTestBehavior;
701
    renderObject.updateGestureRecognizers(gestureRecognizers);
702 703
  }
}
704

705 706
/// The parameters used to create a [PlatformViewController].
///
707 708 709
/// See also:
///
///  * [CreatePlatformViewCallback] which uses this object to create a [PlatformViewController].
710 711 712 713
class PlatformViewCreationParams {

  const PlatformViewCreationParams._({
    @required this.id,
714
    @required this.viewType,
715 716
    @required this.onPlatformViewCreated,
    @required this.onFocusChanged,
717 718 719 720 721 722 723 724
  }) : assert(id != null),
       assert(onPlatformViewCreated != null);

  /// The unique identifier for the new platform view.
  ///
  /// [PlatformViewController.viewId] should match this id.
  final int id;

725 726 727 728 729 730
  /// The unique identifier for the type of platform view to be embedded.
  ///
  /// This viewType is used to tell the platform which type of view to
  /// associate with the [id].
  final String viewType;

731 732
  /// Callback invoked after the platform view has been created.
  final PlatformViewCreatedCallback onPlatformViewCreated;
733 734 735 736 737

  /// Callback invoked when the platform view's focus is changed on the platform side.
  ///
  /// The value is true when the platform view gains focus and false when it loses focus.
  final ValueChanged<bool> onFocusChanged;
738 739 740 741 742 743 744
}

/// A factory for a surface presenting a platform view as part of the widget hierarchy.
///
/// The returned widget should present the platform view associated with `controller`.
///
/// See also:
745 746
///
///  * [PlatformViewSurface], a common widget for presenting platform views.
747 748 749 750
typedef PlatformViewSurfaceFactory = Widget Function(BuildContext context, PlatformViewController controller);

/// Constructs a [PlatformViewController].
///
751
/// The [PlatformViewController.viewId] field of the created controller must match the value of the
752 753
/// params [PlatformViewCreationParams.id] field.
///
754 755 756
/// See also:
///
///  * [PlatformViewLink], which links a platform view with the Flutter framework.
757
typedef CreatePlatformViewCallback = PlatformViewController Function(PlatformViewCreationParams params);
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772

/// Links a platform view with the Flutter framework.
///
/// Provides common functionality for embedding a platform view (e.g an android.view.View on Android)
/// with the Flutter framework.
///
/// {@macro flutter.widgets.platformViews.lifetime}
///
/// To implement a new platform view widget, return this widget in the `build` method.
/// For example:
/// ```dart
/// class FooPlatformView extends StatelessWidget {
///   @override
///   Widget build(BuildContext context) {
///     return PlatformViewLink(
773
///       viewType: 'webview',
774
///       onCreatePlatformView: createFooWebView,
775 776 777 778 779 780 781 782 783 784 785 786
///       surfaceFactory: (BuildContext context, PlatformViewController controller) {
///        return PlatformViewSurface(
///            gestureRecognizers: gestureRecognizers,
///            controller: controller,
///            hitTestBehavior: PlatformViewHitTestBehavior.opaque,
///        );
///       },
///    );
///   }
/// }
/// ```
///
787 788
/// The `surfaceFactory` and the `onCreatePlatformView` are only called when the
/// state of this widget is initialized, or when the `viewType` changes.
789 790 791 792
class PlatformViewLink extends StatefulWidget {

  /// Construct a [PlatformViewLink] widget.
  ///
793
  /// The `surfaceFactory` and the `onCreatePlatformView` must not be null.
794 795
  ///
  /// See also:
796 797 798
  ///
  ///  * [PlatformViewSurface] for details on the widget returned by `surfaceFactory`.
  ///  * [PlatformViewCreationParams] for how each parameter can be used when implementing `createPlatformView`.
799 800 801
  const PlatformViewLink({
    Key key,
    @required PlatformViewSurfaceFactory surfaceFactory,
802
    @required CreatePlatformViewCallback onCreatePlatformView,
803
    @required this.viewType,
804
    }) : assert(surfaceFactory != null),
805 806 807 808 809
         assert(onCreatePlatformView != null),
         assert(viewType != null),
         _surfaceFactory = surfaceFactory,
         _onCreatePlatformView = onCreatePlatformView,
         super(key: key);
810 811 812


  final PlatformViewSurfaceFactory _surfaceFactory;
813
  final CreatePlatformViewCallback _onCreatePlatformView;
814

815 816 817 818 819
  /// The unique identifier for the view type to be embedded.
  ///
  /// Typically, this viewType has already been registered on the platform side.
  final String viewType;

820 821 822 823 824 825 826 827 828
  @override
  State<StatefulWidget> createState() => _PlatformViewLinkState();
}

class _PlatformViewLinkState extends State<PlatformViewLink> {

  int _id;
  PlatformViewController _controller;
  bool _platformViewCreated = false;
829
  Widget _surface;
830
  FocusNode _focusNode;
831 832 833 834 835 836 837

  @override
  Widget build(BuildContext context) {
    if (!_platformViewCreated) {
      return const SizedBox.expand();
    }
    _surface ??= widget._surfaceFactory(context, _controller);
838 839 840 841 842
    return Focus(
      focusNode: _focusNode,
      onFocusChange: _handleFrameworkFocusChanged,
      child: _surface,
    );
843 844 845 846
  }

  @override
  void initState() {
847
    _focusNode = FocusNode(debugLabel: 'PlatformView(id: $_id)',);
848 849 850 851
    _initialize();
    super.initState();
  }

852 853 854 855 856 857
  @override
  void didUpdateWidget(PlatformViewLink oldWidget) {
    super.didUpdateWidget(oldWidget);

    if (widget.viewType != oldWidget.viewType) {
      _controller?.dispose();
858 859 860
      // The _surface has to be recreated as its controller is disposed.
      // Setting _surface to null will trigger its creation in build().
      _surface = null;
861 862 863 864 865 866 867

      // We are about to create a new platform view.
      _platformViewCreated = false;
      _initialize();
    }
  }

868 869
  void _initialize() {
    _id = platformViewsRegistry.getNextPlatformViewId();
870 871
    _controller = widget._onCreatePlatformView(
      PlatformViewCreationParams._(
872 873 874 875
        id: _id,
        viewType: widget.viewType,
        onPlatformViewCreated: _onPlatformViewCreated,
        onFocusChanged: _handlePlatformFocusChanged,
876 877
      ),
    );
878 879 880
  }

  void _onPlatformViewCreated(int id) {
881
    setState(() { _platformViewCreated = true; });
882 883
  }

884 885 886 887 888 889 890 891 892 893 894 895
  void _handleFrameworkFocusChanged(bool isFocused) {
    if (!isFocused) {
      _controller?.clearFocus();
    }
  }

  void _handlePlatformFocusChanged(bool isFocused){
    if (isFocused) {
      _focusNode.requestFocus();
    }
  }

896 897 898
  @override
  void dispose() {
    _controller?.dispose();
899
    _controller = null;
900 901 902 903
    super.dispose();
  }
}

904 905
/// Integrates a platform view with Flutter's compositor, touch, and semantics subsystems.
///
906 907 908
/// The compositor integration is done by adding a [PlatformViewLayer] to the layer tree. [PlatformViewSurface]
/// isn't supported on all platforms (e.g on Android platform views can be composited by using a [TextureLayer] or
/// [AndroidViewSurface]).
909 910 911 912 913 914 915 916
/// Custom Flutter embedders can support [PlatformViewLayer]s by implementing a SystemCompositor.
///
/// The widget fills all available space, the parent of this object must provide bounded layout
/// constraints.
///
/// If the associated platform view is not created the [PlatformViewSurface] does not paint any contents.
///
/// See also:
917
///
918
///  * [AndroidView] which embeds an Android platform view in the widget hierarchy using a [TextureLayer].
919
///  * [UiKitView] which embeds an iOS platform view in the widget hierarchy.
920 921 922 923 924 925 926
// TODO(amirh): Link to the embedder's system compositor documentation once available.
class PlatformViewSurface extends LeafRenderObjectWidget {

  /// Construct a `PlatformViewSurface`.
  ///
  /// The [controller] must not be null.
  const PlatformViewSurface({
927
    Key key,
928
    @required this.controller,
929 930 931 932
    @required this.hitTestBehavior,
    @required this.gestureRecognizers,
  }) : assert(controller != null),
       assert(hitTestBehavior != null),
933 934
       assert(gestureRecognizers != null),
       super(key: key);
935 936 937 938 939 940 941

  /// The controller for the platform view integrated by this [PlatformViewSurface].
  ///
  /// [PlatformViewController] is used for dispatching touch events to the platform view.
  /// [PlatformViewController.viewId] identifies the platform view whose contents are painted by this widget.
  final PlatformViewController controller;

942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
  /// Which gestures should be forwarded to the PlatformView.
  ///
  /// {@macro flutter.widgets.platformViews.gestureRecognizersDescHead}
  ///
  /// For example, with the following setup vertical drags will not be dispatched to the platform view
  /// as the vertical drag gesture is claimed by the parent [GestureDetector].
  ///
  /// ```dart
  /// GestureDetector(
  ///   onVerticalDragStart: (DragStartDetails details) {},
  ///   child: PlatformViewSurface(
  ///   ),
  /// )
  /// ```
  ///
  /// To get the [PlatformViewSurface] to claim the vertical drag gestures we can pass a vertical drag
  /// gesture recognizer factory in [gestureRecognizers] e.g:
  ///
  /// ```dart
  /// GestureDetector(
  ///   onVerticalDragStart: (DragStartDetails details) {},
  ///   child: SizedBox(
  ///     width: 200.0,
  ///     height: 100.0,
  ///     child: PlatformViewSurface(
  ///       gestureRecognizers: <Factory<OneSequenceGestureRecognizer>>[
  ///         new Factory<OneSequenceGestureRecognizer>(
  ///           () => new EagerGestureRecognizer(),
  ///         ),
  ///       ].toSet(),
  ///     ),
  ///   ),
  /// )
  /// ```
  ///
  /// {@macro flutter.widgets.platformViews.gestureRecognizersDescFoot}
  // We use OneSequenceGestureRecognizers as they support gesture arena teams.
  // TODO(amirh): get a list of GestureRecognizers here.
  // https://github.com/flutter/flutter/issues/20953
  final Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers;

  /// {@macro flutter.widgets.platformViews.hittestParam}
  final PlatformViewHitTestBehavior hitTestBehavior;

986 987
  @override
  RenderObject createRenderObject(BuildContext context) {
988
    return PlatformViewRenderBox(controller: controller, gestureRecognizers: gestureRecognizers, hitTestBehavior: hitTestBehavior);
989 990 991 992 993
  }

  @override
  void updateRenderObject(BuildContext context, PlatformViewRenderBox renderObject) {
    renderObject
994 995 996
      ..controller = controller
      ..hitTestBehavior = hitTestBehavior
      ..updateGestureRecognizers(gestureRecognizers);
997 998
  }
}
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013

/// Integrates an Android view with Flutter's compositor, touch, and semantics subsystems.
///
/// The compositor integration is done by adding a [PlatformViewLayer] to the layer tree. [PlatformViewLayer]
/// isn't supported on all platforms. Custom Flutter embedders can support
/// [PlatformViewLayer]s by implementing a SystemCompositor.
///
/// The widget fills all available space, the parent of this object must provide bounded layout
/// constraints.
///
/// If the associated platform view is not created, the [AndroidViewSurface] does not paint any contents.
///
/// See also:
///
///  * [AndroidView] which embeds an Android platform view in the widget hierarchy using a [TextureLayer].
1014
///  * [UiKitView] which embeds an iOS platform view in the widget hierarchy.
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
class AndroidViewSurface extends PlatformViewSurface {
  /// Construct an `AndroidPlatformViewSurface`.
  const AndroidViewSurface({
    Key key,
    @required AndroidViewController controller,
    @required PlatformViewHitTestBehavior hitTestBehavior,
    @required Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers,
  }) : assert(controller != null),
       assert(hitTestBehavior != null),
       assert(gestureRecognizers != null),
       super(
          key: key,
          controller: controller,
          hitTestBehavior: hitTestBehavior,
          gestureRecognizers: gestureRecognizers);

  @override
  RenderObject createRenderObject(BuildContext context) {
    final PlatformViewRenderBox renderBox =
        super.createRenderObject(context) as PlatformViewRenderBox;

    (controller as AndroidViewController).pointTransformer =
        (Offset position) => renderBox.globalToLocal(position);

    return renderBox;
  }
}