Split into 3 files

* webview_flutter_tizen.dart : webview part
* platform_view.dart : platform view part imported without modification
* platform_view_tizen.dart : custom platform view part

Signed-off-by: MuHong Byun <[email protected]>

Author: bwikbs

packages/webview_flutter/lib/platform_view.dart

@@ -0,0 +1,243 @@
+// Copyright 2021 Samsung Electronics Co., Ltd. All rights reserved.
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// github.com:flutter/flutter.git@02c026b03cd31dd3f867e5faeb7e104cce174c5f
+// packages/flutter/lib/src/rendering/platform_view.dart
+// Imported from above file, the content has not been modified.
+
+part of 'webview_flutter_tizen.dart';
+
+/// How an embedded platform view behave during hit tests.
+enum PlatformViewHitTestBehavior {
+  /// Opaque targets can be hit by hit tests, causing them to both receive
+  /// events within their bounds and prevent targets visually behind them from
+  /// also receiving events.
+  opaque,
+
+  /// Translucent targets both receive events within their bounds and permit
+  /// targets visually behind them to also receive events.
+  translucent,
+
+  /// Transparent targets don't receive events within their bounds and permit
+  /// targets visually behind them to receive events.
+  transparent,
+}
+
+enum _PlatformViewState {
+  uninitialized,
+  resizing,
+  ready,
+}
+
+bool _factoryTypesSetEquals<T>(Set<Factory<T>>? a, Set<Factory<T>>? b) {
+  if (a == b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  return setEquals(_factoriesTypeSet(a), _factoriesTypeSet(b));
+}
+
+Set<Type> _factoriesTypeSet<T>(Set<Factory<T>> factories) {
+  return factories.map<Type>((Factory<T> factory) => factory.type).toSet();
+}
+
+typedef _HandlePointerEvent = Future<void> Function(PointerEvent event);
+
+// This recognizer constructs gesture recognizers from a set of gesture recognizer factories
+// it was give, adds all of them to a gesture arena team with the _PlatformViewGestureRecognizer
+// as the team captain.
+// As long as the gesture arena is unresolved, the recognizer caches all pointer events.
+// When the team wins, the recognizer sends all the cached pointer events to `_handlePointerEvent`, and
+// sets itself to a "forwarding mode" where it will forward any new pointer event to `_handlePointerEvent`.
+class _PlatformViewGestureRecognizer extends OneSequenceGestureRecognizer {
+  _PlatformViewGestureRecognizer(
+    _HandlePointerEvent handlePointerEvent,
+    this.gestureRecognizerFactories, {
+    PointerDeviceKind? kind,
+  }) : super(kind: kind) {
+    team = GestureArenaTeam()..captain = this;
+    _gestureRecognizers = gestureRecognizerFactories.map(
+      (Factory<OneSequenceGestureRecognizer> recognizerFactory) {
+        final OneSequenceGestureRecognizer gestureRecognizer =
+            recognizerFactory.constructor();
+        gestureRecognizer.team = team;
+        // The below gesture recognizers requires at least one non-empty callback to
+        // compete in the gesture arena.
+        // https://github.com/flutter/flutter/issues/35394#issuecomment-562285087
+        if (gestureRecognizer is LongPressGestureRecognizer) {
+          gestureRecognizer.onLongPress ??= () {};
+        } else if (gestureRecognizer is DragGestureRecognizer) {
+          gestureRecognizer.onDown ??= (_) {};
+        } else if (gestureRecognizer is TapGestureRecognizer) {
+          gestureRecognizer.onTapDown ??= (_) {};
+        }
+        return gestureRecognizer;
+      },
+    ).toSet();
+    _handlePointerEvent = handlePointerEvent;
+  }
+
+  late _HandlePointerEvent _handlePointerEvent;
+
+  // Maps a pointer to a list of its cached pointer events.
+  // Before the arena for a pointer is resolved all events are cached here, if we win the arena
+  // the cached events are dispatched to `_handlePointerEvent`, if we lose the arena we clear the cache for
+  // the pointer.
+  final Map<int, List<PointerEvent>> cachedEvents = <int, List<PointerEvent>>{};
+
+  // Pointer for which we have already won the arena, events for pointers in this set are
+  // immediately dispatched to `_handlePointerEvent`.
+  final Set<int> forwardedPointers = <int>{};
+
+  // 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>> gestureRecognizerFactories;
+  late Set<OneSequenceGestureRecognizer> _gestureRecognizers;
+
+  @override
+  void addAllowedPointer(PointerDownEvent event) {
+    startTrackingPointer(event.pointer, event.transform);
+    for (final OneSequenceGestureRecognizer recognizer in _gestureRecognizers) {
+      recognizer.addPointer(event);
+    }
+  }
+
+  @override
+  String get debugDescription => 'Platform view';
+
+  @override
+  void didStopTrackingLastPointer(int pointer) {}
+
+  @override
+  void handleEvent(PointerEvent event) {
+    if (!forwardedPointers.contains(event.pointer)) {
+      _cacheEvent(event);
+    } else {
+      _handlePointerEvent(event);
+    }
+    stopTrackingIfPointerNoLongerDown(event);
+  }
+
+  @override
+  void acceptGesture(int pointer) {
+    _flushPointerCache(pointer);
+    forwardedPointers.add(pointer);
+  }
+
+  @override
+  void rejectGesture(int pointer) {
+    stopTrackingPointer(pointer);
+    cachedEvents.remove(pointer);
+  }
+
+  void _cacheEvent(PointerEvent event) {
+    if (!cachedEvents.containsKey(event.pointer)) {
+      cachedEvents[event.pointer] = <PointerEvent>[];
+    }
+    cachedEvents[event.pointer]!.add(event);
+  }
+
+  void _flushPointerCache(int pointer) {
+    cachedEvents.remove(pointer)?.forEach(_handlePointerEvent);
+  }
+
+  @override
+  void stopTrackingPointer(int pointer) {
+    super.stopTrackingPointer(pointer);
+    forwardedPointers.remove(pointer);
+  }
+
+  void reset() {
+    forwardedPointers.forEach(super.stopTrackingPointer);
+    forwardedPointers.clear();
+    cachedEvents.keys.forEach(super.stopTrackingPointer);
+    cachedEvents.clear();
+    resolve(GestureDisposition.rejected);
+  }
+}
+
+/// The Mixin handling the pointer events and gestures of a platform view render box.
+mixin _PlatformViewGestureMixin on RenderBox implements MouseTrackerAnnotation {
+  /// How to behave during hit testing.
+  // Changing _hitTestBehavior might affect which objects are considered hovered over.
+  set hitTestBehavior(PlatformViewHitTestBehavior value) {
+    if (value != _hitTestBehavior) {
+      _hitTestBehavior = value;
+      if (owner != null) markNeedsPaint();
+    }
+  }
+
+  PlatformViewHitTestBehavior? _hitTestBehavior;
+
+  _HandlePointerEvent? _handlePointerEvent;
+
+  /// Any active gesture arena the `PlatformView` participates in is rejected when the
+  /// set of gesture recognizers is changed.
+  void _updateGestureRecognizersWithCallBack(
+      Set<Factory<OneSequenceGestureRecognizer>> gestureRecognizers,
+      _HandlePointerEvent handlePointerEvent) {
+    assert(gestureRecognizers != null);
+    assert(
+      _factoriesTypeSet(gestureRecognizers).length == gestureRecognizers.length,
+      'There were multiple gesture recognizer factories for the same type, there must only be a single '
+      'gesture recognizer factory for each gesture recognizer type.',
+    );
+    if (_factoryTypesSetEquals(
+        gestureRecognizers, _gestureRecognizer?.gestureRecognizerFactories)) {
+      return;
+    }
+    _gestureRecognizer?.dispose();
+    _gestureRecognizer =
+        _PlatformViewGestureRecognizer(handlePointerEvent, gestureRecognizers);
+    _handlePointerEvent = handlePointerEvent;
+  }
+
+  _PlatformViewGestureRecognizer? _gestureRecognizer;
+
+  @override
+  bool hitTest(BoxHitTestResult result, {required Offset position}) {
+    if (_hitTestBehavior == PlatformViewHitTestBehavior.transparent ||
+        !size.contains(position)) {
+      return false;
+    }
+    result.add(BoxHitTestEntry(this, position));
+    return _hitTestBehavior == PlatformViewHitTestBehavior.opaque;
+  }
+
+  @override
+  bool hitTestSelf(Offset position) =>
+      _hitTestBehavior != PlatformViewHitTestBehavior.transparent;
+
+  @override
+  PointerEnterEventListener? get onEnter => null;
+
+  @override
+  PointerExitEventListener? get onExit => null;
+
+  @override
+  MouseCursor get cursor => MouseCursor.uncontrolled;
+
+  @override
+  bool get validForMouseTracker => true;
+
+  @override
+  void handleEvent(PointerEvent event, HitTestEntry entry) {
+    if (event is PointerDownEvent) {
+      _gestureRecognizer!.addPointer(event);
+    }
+    if (event is PointerHoverEvent) {
+      _handlePointerEvent?.call(event);
+    }
+  }
+
+  @override
+  void detach() {
+    _gestureRecognizer!.reset();
+    super.detach();
+  }
+}