packages/google_maps_flutter/google_maps_flutter_platform_interface/lib/src/method_channel/method_channel_google_maps_flutter.dart - mirrors/plugins - Git at Google

 // 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.

 import 'dart:async';
 // TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
 // ignore: unnecessary_import
 import 'dart:typed_data';

 import 'package:flutter/foundation.dart';
 import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter/services.dart';
 import 'package:stream_transform/stream_transform.dart';

 import '../../google_maps_flutter_platform_interface.dart';
 import '../types/tile_overlay_updates.dart';
 import '../types/utils/map_configuration_serialization.dart';

 /// Error thrown when an unknown map ID is provided to a method channel API.
 class UnknownMapIDError extends Error {
   /// Creates an assertion error with the provided [mapId] and optional
   /// [message].
   UnknownMapIDError(this.mapId, [this.message]);

   /// The unknown ID.
   final int mapId;

   /// Message describing the assertion error.
   final Object? message;

   @override
   String toString() {
     if (message != null) {
       return 'Unknown map ID $mapId: ${Error.safeToString(message)}';
     }
     return 'Unknown map ID $mapId';
   }
 }

 /// An implementation of [GoogleMapsFlutterPlatform] that uses [MethodChannel] to communicate with the native code.
 ///
 /// The `google_maps_flutter` plugin code itself never talks to the native code directly. It delegates
 /// all those calls to an instance of a class that extends the GoogleMapsFlutterPlatform.
 ///
 /// The architecture above allows for platforms that communicate differently with the native side
 /// (like web) to have a common interface to extend.
 ///
 /// This is the instance that runs when the native side talks to your Flutter app through MethodChannels,
 /// like the Android and iOS platforms.
 class MethodChannelGoogleMapsFlutter extends GoogleMapsFlutterPlatform {
   // Keep a collection of id -> channel
   // Every method call passes the int mapId
   final Map<int, MethodChannel> _channels = <int, MethodChannel>{};

   /// Accesses the MethodChannel associated to the passed mapId.
   MethodChannel channel(int mapId) {
     final MethodChannel? channel = _channels[mapId];
     if (channel == null) {
       throw UnknownMapIDError(mapId);
     }
     return channel;
   }

   // Keep a collection of mapId to a map of TileOverlays.
   final Map<int, Map<TileOverlayId, TileOverlay>> _tileOverlays =
       <int, Map<TileOverlayId, TileOverlay>>{};

   /// Returns the channel for [mapId], creating it if it doesn't already exist.
   @visibleForTesting
   MethodChannel ensureChannelInitialized(int mapId) {
     MethodChannel? channel = _channels[mapId];
     if (channel == null) {
       channel = MethodChannel('plugins.flutter.io/google_maps_$mapId');
       channel.setMethodCallHandler(
           (MethodCall call) => _handleMethodCall(call, mapId));
       _channels[mapId] = channel;
     }
     return channel;
   }

   @override
   Future<void> init(int mapId) {
     final MethodChannel channel = ensureChannelInitialized(mapId);
     return channel.invokeMethod<void>('map#waitForMap');
   }

   @override
   void dispose({required int mapId}) {
     // Noop!
   }

   // The controller we need to broadcast the different events coming
   // from handleMethodCall.
   //
   // It is a `broadcast` because multiple controllers will connect to
   // different stream views of this Controller.
   final StreamController<MapEvent<Object?>> _mapEventStreamController =
       StreamController<MapEvent<Object?>>.broadcast();

   // Returns a filtered view of the events in the _controller, by mapId.
   Stream<MapEvent<Object?>> _events(int mapId) =>
       _mapEventStreamController.stream
           .where((MapEvent<Object?> event) => event.mapId == mapId);

   @override
   Stream<CameraMoveStartedEvent> onCameraMoveStarted({required int mapId}) {
     return _events(mapId).whereType<CameraMoveStartedEvent>();
   }

   @override
   Stream<CameraMoveEvent> onCameraMove({required int mapId}) {
     return _events(mapId).whereType<CameraMoveEvent>();
   }

   @override
   Stream<CameraIdleEvent> onCameraIdle({required int mapId}) {
     return _events(mapId).whereType<CameraIdleEvent>();
   }

   @override
   Stream<MarkerTapEvent> onMarkerTap({required int mapId}) {
     return _events(mapId).whereType<MarkerTapEvent>();
   }

   @override
   Stream<InfoWindowTapEvent> onInfoWindowTap({required int mapId}) {
     return _events(mapId).whereType<InfoWindowTapEvent>();
   }

   @override
   Stream<MarkerDragStartEvent> onMarkerDragStart({required int mapId}) {
     return _events(mapId).whereType<MarkerDragStartEvent>();
   }

   @override
   Stream<MarkerDragEvent> onMarkerDrag({required int mapId}) {
     return _events(mapId).whereType<MarkerDragEvent>();
   }

   @override
   Stream<MarkerDragEndEvent> onMarkerDragEnd({required int mapId}) {
     return _events(mapId).whereType<MarkerDragEndEvent>();
   }

   @override
   Stream<PolylineTapEvent> onPolylineTap({required int mapId}) {
     return _events(mapId).whereType<PolylineTapEvent>();
   }

   @override
   Stream<PolygonTapEvent> onPolygonTap({required int mapId}) {
     return _events(mapId).whereType<PolygonTapEvent>();
   }

   @override
   Stream<CircleTapEvent> onCircleTap({required int mapId}) {
     return _events(mapId).whereType<CircleTapEvent>();
   }

   @override
   Stream<MapTapEvent> onTap({required int mapId}) {
     return _events(mapId).whereType<MapTapEvent>();
   }

   @override
   Stream<MapLongPressEvent> onLongPress({required int mapId}) {
     return _events(mapId).whereType<MapLongPressEvent>();
   }

   Future<dynamic> _handleMethodCall(MethodCall call, int mapId) async {
     switch (call.method) {
       case 'camera#onMoveStarted':
         _mapEventStreamController.add(CameraMoveStartedEvent(mapId));
         break;
       case 'camera#onMove':
         _mapEventStreamController.add(CameraMoveEvent(
           mapId,
           CameraPosition.fromMap(call.arguments['position'])!,
         ));
         break;
       case 'camera#onIdle':
         _mapEventStreamController.add(CameraIdleEvent(mapId));
         break;
       case 'marker#onTap':
         _mapEventStreamController.add(MarkerTapEvent(
           mapId,
           MarkerId(call.arguments['markerId'] as String),
         ));
         break;
       case 'marker#onDragStart':
         _mapEventStreamController.add(MarkerDragStartEvent(
           mapId,
           LatLng.fromJson(call.arguments['position'])!,
           MarkerId(call.arguments['markerId'] as String),
         ));
         break;
       case 'marker#onDrag':
         _mapEventStreamController.add(MarkerDragEvent(
           mapId,
           LatLng.fromJson(call.arguments['position'])!,
           MarkerId(call.arguments['markerId'] as String),
         ));
         break;
       case 'marker#onDragEnd':
         _mapEventStreamController.add(MarkerDragEndEvent(
           mapId,
           LatLng.fromJson(call.arguments['position'])!,
           MarkerId(call.arguments['markerId'] as String),
         ));
         break;
       case 'infoWindow#onTap':
         _mapEventStreamController.add(InfoWindowTapEvent(
           mapId,
           MarkerId(call.arguments['markerId'] as String),
         ));
         break;
       case 'polyline#onTap':
         _mapEventStreamController.add(PolylineTapEvent(
           mapId,
           PolylineId(call.arguments['polylineId'] as String),
         ));
         break;
       case 'polygon#onTap':
         _mapEventStreamController.add(PolygonTapEvent(
           mapId,
           PolygonId(call.arguments['polygonId'] as String),
         ));
         break;
       case 'circle#onTap':
         _mapEventStreamController.add(CircleTapEvent(
           mapId,
           CircleId(call.arguments['circleId'] as String),
         ));
         break;
       case 'map#onTap':
         _mapEventStreamController.add(MapTapEvent(
           mapId,
           LatLng.fromJson(call.arguments['position'])!,
         ));
         break;
       case 'map#onLongPress':
         _mapEventStreamController.add(MapLongPressEvent(
           mapId,
           LatLng.fromJson(call.arguments['position'])!,
         ));
         break;
       case 'tileOverlay#getTile':
         final Map<TileOverlayId, TileOverlay>? tileOverlaysForThisMap =
             _tileOverlays[mapId];
         final String tileOverlayId = call.arguments['tileOverlayId'] as String;
         final TileOverlay? tileOverlay =
             tileOverlaysForThisMap?[TileOverlayId(tileOverlayId)];
         final TileProvider? tileProvider = tileOverlay?.tileProvider;
         if (tileProvider == null) {
           return TileProvider.noTile.toJson();
         }
         final Tile tile = await tileProvider.getTile(
           call.arguments['x'] as int,
           call.arguments['y'] as int,
           call.arguments['zoom'] as int?,
         );
         return tile.toJson();
       default:
         throw MissingPluginException();
     }
   }

   @override
   Future<void> updateMapOptions(
     Map<String, dynamic> optionsUpdate, {
     required int mapId,
   }) {
     assert(optionsUpdate != null);
     return channel(mapId).invokeMethod<void>(
       'map#update',
       <String, dynamic>{
         'options': optionsUpdate,
       },
     );
   }

   @override
   Future<void> updateMarkers(
     MarkerUpdates markerUpdates, {
     required int mapId,
   }) {
     assert(markerUpdates != null);
     return channel(mapId).invokeMethod<void>(
       'markers#update',
       markerUpdates.toJson(),
     );
   }

   @override
   Future<void> updatePolygons(
     PolygonUpdates polygonUpdates, {
     required int mapId,
   }) {
     assert(polygonUpdates != null);
     return channel(mapId).invokeMethod<void>(
       'polygons#update',
       polygonUpdates.toJson(),
     );
   }

   @override
   Future<void> updatePolylines(
     PolylineUpdates polylineUpdates, {
     required int mapId,
   }) {
     assert(polylineUpdates != null);
     return channel(mapId).invokeMethod<void>(
       'polylines#update',
       polylineUpdates.toJson(),
     );
   }

   @override
   Future<void> updateCircles(
     CircleUpdates circleUpdates, {
     required int mapId,
   }) {
     assert(circleUpdates != null);
     return channel(mapId).invokeMethod<void>(
       'circles#update',
       circleUpdates.toJson(),
     );
   }

   @override
   Future<void> updateTileOverlays({
     required Set<TileOverlay> newTileOverlays,
     required int mapId,
   }) {
     final Map<TileOverlayId, TileOverlay>? currentTileOverlays =
         _tileOverlays[mapId];
     final Set<TileOverlay> previousSet = currentTileOverlays != null
         ? currentTileOverlays.values.toSet()
         : <TileOverlay>{};
     final TileOverlayUpdates updates =
         TileOverlayUpdates.from(previousSet, newTileOverlays);
     _tileOverlays[mapId] = keyTileOverlayId(newTileOverlays);
     return channel(mapId).invokeMethod<void>(
       'tileOverlays#update',
       updates.toJson(),
     );
   }

   @override
   Future<void> clearTileCache(
     TileOverlayId tileOverlayId, {
     required int mapId,
   }) {
     return channel(mapId)
         .invokeMethod<void>('tileOverlays#clearTileCache', <String, Object>{
       'tileOverlayId': tileOverlayId.value,
     });
   }

   @override
   Future<void> animateCamera(
     CameraUpdate cameraUpdate, {
     required int mapId,
   }) {
     return channel(mapId).invokeMethod<void>('camera#animate', <String, Object>{
       'cameraUpdate': cameraUpdate.toJson(),
     });
   }

   @override
   Future<void> moveCamera(
     CameraUpdate cameraUpdate, {
     required int mapId,
   }) {
     return channel(mapId).invokeMethod<void>('camera#move', <String, dynamic>{
       'cameraUpdate': cameraUpdate.toJson(),
     });
   }

   @override
   Future<void> setMapStyle(
     String? mapStyle, {
     required int mapId,
   }) async {
     final List<dynamic> successAndError = (await channel(mapId)
         .invokeMethod<List<dynamic>>('map#setStyle', mapStyle))!;
     final bool success = successAndError[0] as bool;
     if (!success) {
       throw MapStyleException(successAndError[1] as String);
     }
   }

   @override
   Future<LatLngBounds> getVisibleRegion({
     required int mapId,
   }) async {
     final Map<String, dynamic> latLngBounds = (await channel(mapId)
         .invokeMapMethod<String, dynamic>('map#getVisibleRegion'))!;
     final LatLng southwest = LatLng.fromJson(latLngBounds['southwest'])!;
     final LatLng northeast = LatLng.fromJson(latLngBounds['northeast'])!;

     return LatLngBounds(northeast: northeast, southwest: southwest);
   }

   @override
   Future<ScreenCoordinate> getScreenCoordinate(
     LatLng latLng, {
     required int mapId,
   }) async {
     final Map<String, int> point = (await channel(mapId)
         .invokeMapMethod<String, int>(
             'map#getScreenCoordinate', latLng.toJson()))!;

     return ScreenCoordinate(x: point['x']!, y: point['y']!);
   }

   @override
   Future<LatLng> getLatLng(
     ScreenCoordinate screenCoordinate, {
     required int mapId,
   }) async {
     final List<dynamic> latLng = (await channel(mapId)
         .invokeMethod<List<dynamic>>(
             'map#getLatLng', screenCoordinate.toJson()))!;
     return LatLng(latLng[0] as double, latLng[1] as double);
   }

   @override
   Future<void> showMarkerInfoWindow(
     MarkerId markerId, {
     required int mapId,
   }) {
     assert(markerId != null);
     return channel(mapId).invokeMethod<void>(
         'markers#showInfoWindow', <String, String>{'markerId': markerId.value});
   }

   @override
   Future<void> hideMarkerInfoWindow(
     MarkerId markerId, {
     required int mapId,
   }) {
     assert(markerId != null);
     return channel(mapId).invokeMethod<void>(
         'markers#hideInfoWindow', <String, String>{'markerId': markerId.value});
   }

   @override
   Future<bool> isMarkerInfoWindowShown(
     MarkerId markerId, {
     required int mapId,
   }) async {
     assert(markerId != null);
     return (await channel(mapId).invokeMethod<bool>('markers#isInfoWindowShown',
         <String, String>{'markerId': markerId.value}))!;
   }

   @override
   Future<double> getZoomLevel({
     required int mapId,
   }) async {
     return (await channel(mapId).invokeMethod<double>('map#getZoomLevel'))!;
   }

   @override
   Future<Uint8List?> takeSnapshot({
     required int mapId,
   }) {
     return channel(mapId).invokeMethod<Uint8List>('map#takeSnapshot');
   }

   /// Set [GoogleMapsFlutterPlatform] to use [AndroidViewSurface] to build the Google Maps widget.
   ///
   /// This implementation uses hybrid composition to render the Google Maps
   /// Widget on Android. This comes at the cost of some performance on Android
   /// versions below 10. See
   /// https://flutter.dev/docs/development/platform-integration/platform-views#performance for more
   /// information.
   ///
   /// If set to true, the google map widget should be built with
   /// [buildViewWithTextDirection] instead of [buildView].
   ///
   /// Defaults to false.
   bool useAndroidViewSurface = false;

   Widget _buildView(
     int creationId,
     PlatformViewCreatedCallback onPlatformViewCreated, {
     required MapWidgetConfiguration widgetConfiguration,
     MapObjects mapObjects = const MapObjects(),
     Map<String, dynamic> mapOptions = const <String, dynamic>{},
   }) {
     final Map<String, dynamic> creationParams = <String, dynamic>{
       'initialCameraPosition':
           widgetConfiguration.initialCameraPosition.toMap(),
       'options': mapOptions,
       'markersToAdd': serializeMarkerSet(mapObjects.markers),
       'polygonsToAdd': serializePolygonSet(mapObjects.polygons),
       'polylinesToAdd': serializePolylineSet(mapObjects.polylines),
       'circlesToAdd': serializeCircleSet(mapObjects.circles),
       'tileOverlaysToAdd': serializeTileOverlaySet(mapObjects.tileOverlays),
     };

     if (defaultTargetPlatform == TargetPlatform.android) {
       if (useAndroidViewSurface) {
         return PlatformViewLink(
           viewType: 'plugins.flutter.io/google_maps',
           surfaceFactory: (
             BuildContext context,
             PlatformViewController controller,
           ) {
             return AndroidViewSurface(
               controller: controller as AndroidViewController,
               gestureRecognizers: widgetConfiguration.gestureRecognizers,
               hitTestBehavior: PlatformViewHitTestBehavior.opaque,
             );
           },
           onCreatePlatformView: (PlatformViewCreationParams params) {
             final SurfaceAndroidViewController controller =
                 PlatformViewsService.initSurfaceAndroidView(
               id: params.id,
               viewType: 'plugins.flutter.io/google_maps',
               layoutDirection: widgetConfiguration.textDirection,
               creationParams: creationParams,
               creationParamsCodec: const StandardMessageCodec(),
               onFocus: () => params.onFocusChanged(true),
             );
             controller.addOnPlatformViewCreatedListener(
               params.onPlatformViewCreated,
             );
             controller.addOnPlatformViewCreatedListener(
               onPlatformViewCreated,
             );

             controller.create();
             return controller;
           },
         );
       } else {
         return AndroidView(
           viewType: 'plugins.flutter.io/google_maps',
           onPlatformViewCreated: onPlatformViewCreated,
           gestureRecognizers: widgetConfiguration.gestureRecognizers,
           creationParams: creationParams,
           creationParamsCodec: const StandardMessageCodec(),
         );
       }
     } else if (defaultTargetPlatform == TargetPlatform.iOS) {
       return UiKitView(
         viewType: 'plugins.flutter.io/google_maps',
         onPlatformViewCreated: onPlatformViewCreated,
         gestureRecognizers: widgetConfiguration.gestureRecognizers,
         creationParams: creationParams,
         creationParamsCodec: const StandardMessageCodec(),
       );
     }

     return Text(
         '$defaultTargetPlatform is not yet supported by the maps plugin');
   }

   @override
   Widget buildViewWithConfiguration(
     int creationId,
     PlatformViewCreatedCallback onPlatformViewCreated, {
     required MapWidgetConfiguration widgetConfiguration,
     MapConfiguration mapConfiguration = const MapConfiguration(),
     MapObjects mapObjects = const MapObjects(),
   }) {
     return _buildView(
       creationId,
       onPlatformViewCreated,
       widgetConfiguration: widgetConfiguration,
       mapObjects: mapObjects,
       mapOptions: jsonForMapConfiguration(mapConfiguration),
     );
   }

   @override
   Widget buildViewWithTextDirection(
     int creationId,
     PlatformViewCreatedCallback onPlatformViewCreated, {
     required CameraPosition initialCameraPosition,
     required TextDirection textDirection,
     Set<Marker> markers = const <Marker>{},
     Set<Polygon> polygons = const <Polygon>{},
     Set<Polyline> polylines = const <Polyline>{},
     Set<Circle> circles = const <Circle>{},
     Set<TileOverlay> tileOverlays = const <TileOverlay>{},
     Set<Factory<OneSequenceGestureRecognizer>>? gestureRecognizers,
     Map<String, dynamic> mapOptions = const <String, dynamic>{},
   }) {
     return _buildView(
       creationId,
       onPlatformViewCreated,
       widgetConfiguration: MapWidgetConfiguration(
           initialCameraPosition: initialCameraPosition,
           textDirection: textDirection),
       mapObjects: MapObjects(
           markers: markers,
           polygons: polygons,
           polylines: polylines,
           circles: circles,
           tileOverlays: tileOverlays),
       mapOptions: mapOptions,
     );
   }

   @override
   Widget buildView(
     int creationId,
     PlatformViewCreatedCallback onPlatformViewCreated, {
     required CameraPosition initialCameraPosition,
     Set<Marker> markers = const <Marker>{},
     Set<Polygon> polygons = const <Polygon>{},
     Set<Polyline> polylines = const <Polyline>{},
     Set<Circle> circles = const <Circle>{},
     Set<TileOverlay> tileOverlays = const <TileOverlay>{},
     Set<Factory<OneSequenceGestureRecognizer>>? gestureRecognizers,
     Map<String, dynamic> mapOptions = const <String, dynamic>{},
   }) {
     return buildViewWithTextDirection(
       creationId,
       onPlatformViewCreated,
       initialCameraPosition: initialCameraPosition,
       textDirection: TextDirection.ltr,
       markers: markers,
       polygons: polygons,
       polylines: polylines,
       circles: circles,
       tileOverlays: tileOverlays,
       gestureRecognizers: gestureRecognizers,
       mapOptions: mapOptions,
     );
   }
 }
	// 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.

	import 'dart:async';
	// TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
	// ignore: unnecessary_import
	import 'dart:typed_data';

	import 'package:flutter/foundation.dart';
	import 'package:flutter/gestures.dart';
	import 'package:flutter/material.dart';
	import 'package:flutter/rendering.dart';
	import 'package:flutter/services.dart';
	import 'package:stream_transform/stream_transform.dart';

	import '../../google_maps_flutter_platform_interface.dart';
	import '../types/tile_overlay_updates.dart';
	import '../types/utils/map_configuration_serialization.dart';

	/// Error thrown when an unknown map ID is provided to a method channel API.
	class UnknownMapIDError extends Error {
	/// Creates an assertion error with the provided [mapId] and optional
	/// [message].
	UnknownMapIDError(this.mapId, [this.message]);

	/// The unknown ID.
	final int mapId;

	/// Message describing the assertion error.
	final Object? message;

	@override
	String toString() {
	if (message != null) {
	return 'Unknown map ID $mapId: ${Error.safeToString(message)}';
	}
	return 'Unknown map ID $mapId';
	}
	}

	/// An implementation of [GoogleMapsFlutterPlatform] that uses [MethodChannel] to communicate with the native code.
	///
	/// The `google_maps_flutter` plugin code itself never talks to the native code directly. It delegates
	/// all those calls to an instance of a class that extends the GoogleMapsFlutterPlatform.
	///
	/// The architecture above allows for platforms that communicate differently with the native side
	/// (like web) to have a common interface to extend.
	///
	/// This is the instance that runs when the native side talks to your Flutter app through MethodChannels,
	/// like the Android and iOS platforms.
	class MethodChannelGoogleMapsFlutter extends GoogleMapsFlutterPlatform {
	// Keep a collection of id -> channel
	// Every method call passes the int mapId
	final Map<int, MethodChannel> _channels = <int, MethodChannel>{};

	/// Accesses the MethodChannel associated to the passed mapId.
	MethodChannel channel(int mapId) {
	final MethodChannel? channel = _channels[mapId];
	if (channel == null) {
	throw UnknownMapIDError(mapId);
	}
	return channel;
	}

	// Keep a collection of mapId to a map of TileOverlays.
	final Map<int, Map<TileOverlayId, TileOverlay>> _tileOverlays =
	<int, Map<TileOverlayId, TileOverlay>>{};

	/// Returns the channel for [mapId], creating it if it doesn't already exist.
	@visibleForTesting
	MethodChannel ensureChannelInitialized(int mapId) {
	MethodChannel? channel = _channels[mapId];
	if (channel == null) {
	channel = MethodChannel('plugins.flutter.io/google_maps_$mapId');
	channel.setMethodCallHandler(
	(MethodCall call) => _handleMethodCall(call, mapId));
	_channels[mapId] = channel;
	}
	return channel;
	}

	@override
	Future<void> init(int mapId) {
	final MethodChannel channel = ensureChannelInitialized(mapId);
	return channel.invokeMethod<void>('map#waitForMap');
	}

	@override
	void dispose({required int mapId}) {
	// Noop!
	}

	// The controller we need to broadcast the different events coming
	// from handleMethodCall.
	//
	// It is a `broadcast` because multiple controllers will connect to
	// different stream views of this Controller.
	final StreamController<MapEvent<Object?>> _mapEventStreamController =
	StreamController<MapEvent<Object?>>.broadcast();

	// Returns a filtered view of the events in the _controller, by mapId.
	Stream<MapEvent<Object?>> _events(int mapId) =>
	_mapEventStreamController.stream
	.where((MapEvent<Object?> event) => event.mapId == mapId);

	@override
	Stream<CameraMoveStartedEvent> onCameraMoveStarted({required int mapId}) {
	return _events(mapId).whereType<CameraMoveStartedEvent>();
	}

	@override
	Stream<CameraMoveEvent> onCameraMove({required int mapId}) {
	return _events(mapId).whereType<CameraMoveEvent>();
	}

	@override
	Stream<CameraIdleEvent> onCameraIdle({required int mapId}) {
	return _events(mapId).whereType<CameraIdleEvent>();
	}

	@override
	Stream<MarkerTapEvent> onMarkerTap({required int mapId}) {
	return _events(mapId).whereType<MarkerTapEvent>();
	}

	@override
	Stream<InfoWindowTapEvent> onInfoWindowTap({required int mapId}) {
	return _events(mapId).whereType<InfoWindowTapEvent>();
	}

	@override
	Stream<MarkerDragStartEvent> onMarkerDragStart({required int mapId}) {
	return _events(mapId).whereType<MarkerDragStartEvent>();
	}

	@override
	Stream<MarkerDragEvent> onMarkerDrag({required int mapId}) {
	return _events(mapId).whereType<MarkerDragEvent>();
	}

	@override
	Stream<MarkerDragEndEvent> onMarkerDragEnd({required int mapId}) {
	return _events(mapId).whereType<MarkerDragEndEvent>();
	}

	@override
	Stream<PolylineTapEvent> onPolylineTap({required int mapId}) {
	return _events(mapId).whereType<PolylineTapEvent>();
	}

	@override
	Stream<PolygonTapEvent> onPolygonTap({required int mapId}) {
	return _events(mapId).whereType<PolygonTapEvent>();
	}

	@override
	Stream<CircleTapEvent> onCircleTap({required int mapId}) {
	return _events(mapId).whereType<CircleTapEvent>();
	}

	@override
	Stream<MapTapEvent> onTap({required int mapId}) {
	return _events(mapId).whereType<MapTapEvent>();
	}

	@override
	Stream<MapLongPressEvent> onLongPress({required int mapId}) {
	return _events(mapId).whereType<MapLongPressEvent>();
	}

	Future<dynamic> _handleMethodCall(MethodCall call, int mapId) async {
	switch (call.method) {
	case 'camera#onMoveStarted':
	_mapEventStreamController.add(CameraMoveStartedEvent(mapId));
	break;
	case 'camera#onMove':
	_mapEventStreamController.add(CameraMoveEvent(
	mapId,
	CameraPosition.fromMap(call.arguments['position'])!,
	));
	break;
	case 'camera#onIdle':
	_mapEventStreamController.add(CameraIdleEvent(mapId));
	break;
	case 'marker#onTap':
	_mapEventStreamController.add(MarkerTapEvent(
	mapId,
	MarkerId(call.arguments['markerId'] as String),
	));
	break;
	case 'marker#onDragStart':
	_mapEventStreamController.add(MarkerDragStartEvent(
	mapId,
	LatLng.fromJson(call.arguments['position'])!,
	MarkerId(call.arguments['markerId'] as String),
	));
	break;
	case 'marker#onDrag':
	_mapEventStreamController.add(MarkerDragEvent(
	mapId,
	LatLng.fromJson(call.arguments['position'])!,
	MarkerId(call.arguments['markerId'] as String),
	));
	break;
	case 'marker#onDragEnd':
	_mapEventStreamController.add(MarkerDragEndEvent(
	mapId,
	LatLng.fromJson(call.arguments['position'])!,
	MarkerId(call.arguments['markerId'] as String),
	));
	break;
	case 'infoWindow#onTap':
	_mapEventStreamController.add(InfoWindowTapEvent(
	mapId,
	MarkerId(call.arguments['markerId'] as String),
	));
	break;
	case 'polyline#onTap':
	_mapEventStreamController.add(PolylineTapEvent(
	mapId,
	PolylineId(call.arguments['polylineId'] as String),
	));
	break;
	case 'polygon#onTap':
	_mapEventStreamController.add(PolygonTapEvent(
	mapId,
	PolygonId(call.arguments['polygonId'] as String),
	));
	break;
	case 'circle#onTap':
	_mapEventStreamController.add(CircleTapEvent(
	mapId,
	CircleId(call.arguments['circleId'] as String),
	));
	break;
	case 'map#onTap':
	_mapEventStreamController.add(MapTapEvent(
	mapId,
	LatLng.fromJson(call.arguments['position'])!,
	));
	break;
	case 'map#onLongPress':
	_mapEventStreamController.add(MapLongPressEvent(
	mapId,
	LatLng.fromJson(call.arguments['position'])!,
	));
	break;
	case 'tileOverlay#getTile':
	final Map<TileOverlayId, TileOverlay>? tileOverlaysForThisMap =
	_tileOverlays[mapId];
	final String tileOverlayId = call.arguments['tileOverlayId'] as String;
	final TileOverlay? tileOverlay =
	tileOverlaysForThisMap?[TileOverlayId(tileOverlayId)];
	final TileProvider? tileProvider = tileOverlay?.tileProvider;
	if (tileProvider == null) {
	return TileProvider.noTile.toJson();
	}
	final Tile tile = await tileProvider.getTile(
	call.arguments['x'] as int,
	call.arguments['y'] as int,
	call.arguments['zoom'] as int?,
	);
	return tile.toJson();
	default:
	throw MissingPluginException();
	}
	}

	@override
	Future<void> updateMapOptions(
	Map<String, dynamic> optionsUpdate, {
	required int mapId,
	}) {
	assert(optionsUpdate != null);
	return channel(mapId).invokeMethod<void>(
	'map#update',
	<String, dynamic>{
	'options': optionsUpdate,
	},
	);
	}

	@override
	Future<void> updateMarkers(
	MarkerUpdates markerUpdates, {
	required int mapId,
	}) {
	assert(markerUpdates != null);
	return channel(mapId).invokeMethod<void>(
	'markers#update',
	markerUpdates.toJson(),
	);
	}

	@override
	Future<void> updatePolygons(
	PolygonUpdates polygonUpdates, {
	required int mapId,
	}) {
	assert(polygonUpdates != null);
	return channel(mapId).invokeMethod<void>(
	'polygons#update',
	polygonUpdates.toJson(),
	);
	}

	@override
	Future<void> updatePolylines(
	PolylineUpdates polylineUpdates, {
	required int mapId,
	}) {
	assert(polylineUpdates != null);
	return channel(mapId).invokeMethod<void>(
	'polylines#update',
	polylineUpdates.toJson(),
	);
	}

	@override
	Future<void> updateCircles(
	CircleUpdates circleUpdates, {
	required int mapId,
	}) {
	assert(circleUpdates != null);
	return channel(mapId).invokeMethod<void>(
	'circles#update',
	circleUpdates.toJson(),
	);
	}

	@override
	Future<void> updateTileOverlays({
	required Set<TileOverlay> newTileOverlays,
	required int mapId,
	}) {
	final Map<TileOverlayId, TileOverlay>? currentTileOverlays =
	_tileOverlays[mapId];
	final Set<TileOverlay> previousSet = currentTileOverlays != null
	? currentTileOverlays.values.toSet()
	: <TileOverlay>{};
	final TileOverlayUpdates updates =
	TileOverlayUpdates.from(previousSet, newTileOverlays);
	_tileOverlays[mapId] = keyTileOverlayId(newTileOverlays);
	return channel(mapId).invokeMethod<void>(
	'tileOverlays#update',
	updates.toJson(),
	);
	}

	@override
	Future<void> clearTileCache(
	TileOverlayId tileOverlayId, {
	required int mapId,
	}) {
	return channel(mapId)
	.invokeMethod<void>('tileOverlays#clearTileCache', <String, Object>{
	'tileOverlayId': tileOverlayId.value,
	});
	}

	@override
	Future<void> animateCamera(
	CameraUpdate cameraUpdate, {
	required int mapId,
	}) {
	return channel(mapId).invokeMethod<void>('camera#animate', <String, Object>{
	'cameraUpdate': cameraUpdate.toJson(),
	});
	}

	@override
	Future<void> moveCamera(
	CameraUpdate cameraUpdate, {
	required int mapId,
	}) {
	return channel(mapId).invokeMethod<void>('camera#move', <String, dynamic>{
	'cameraUpdate': cameraUpdate.toJson(),
	});
	}

	@override
	Future<void> setMapStyle(
	String? mapStyle, {
	required int mapId,
	}) async {
	final List<dynamic> successAndError = (await channel(mapId)
	.invokeMethod<List<dynamic>>('map#setStyle', mapStyle))!;
	final bool success = successAndError[0] as bool;
	if (!success) {
	throw MapStyleException(successAndError[1] as String);
	}
	}

	@override
	Future<LatLngBounds> getVisibleRegion({
	required int mapId,
	}) async {
	final Map<String, dynamic> latLngBounds = (await channel(mapId)
	.invokeMapMethod<String, dynamic>('map#getVisibleRegion'))!;
	final LatLng southwest = LatLng.fromJson(latLngBounds['southwest'])!;
	final LatLng northeast = LatLng.fromJson(latLngBounds['northeast'])!;

	return LatLngBounds(northeast: northeast, southwest: southwest);
	}

	@override
	Future<ScreenCoordinate> getScreenCoordinate(
	LatLng latLng, {
	required int mapId,
	}) async {
	final Map<String, int> point = (await channel(mapId)
	.invokeMapMethod<String, int>(
	'map#getScreenCoordinate', latLng.toJson()))!;

	return ScreenCoordinate(x: point['x']!, y: point['y']!);
	}

	@override
	Future<LatLng> getLatLng(
	ScreenCoordinate screenCoordinate, {
	required int mapId,
	}) async {
	final List<dynamic> latLng = (await channel(mapId)
	.invokeMethod<List<dynamic>>(
	'map#getLatLng', screenCoordinate.toJson()))!;
	return LatLng(latLng[0] as double, latLng[1] as double);
	}

	@override
	Future<void> showMarkerInfoWindow(
	MarkerId markerId, {
	required int mapId,
	}) {
	assert(markerId != null);
	return channel(mapId).invokeMethod<void>(
	'markers#showInfoWindow', <String, String>{'markerId': markerId.value});
	}

	@override
	Future<void> hideMarkerInfoWindow(
	MarkerId markerId, {
	required int mapId,
	}) {
	assert(markerId != null);
	return channel(mapId).invokeMethod<void>(
	'markers#hideInfoWindow', <String, String>{'markerId': markerId.value});
	}

	@override
	Future<bool> isMarkerInfoWindowShown(
	MarkerId markerId, {
	required int mapId,
	}) async {
	assert(markerId != null);
	return (await channel(mapId).invokeMethod<bool>('markers#isInfoWindowShown',
	<String, String>{'markerId': markerId.value}))!;
	}

	@override
	Future<double> getZoomLevel({
	required int mapId,
	}) async {
	return (await channel(mapId).invokeMethod<double>('map#getZoomLevel'))!;
	}

	@override
	Future<Uint8List?> takeSnapshot({
	required int mapId,
	}) {
	return channel(mapId).invokeMethod<Uint8List>('map#takeSnapshot');
	}

	/// Set [GoogleMapsFlutterPlatform] to use [AndroidViewSurface] to build the Google Maps widget.
	///
	/// This implementation uses hybrid composition to render the Google Maps
	/// Widget on Android. This comes at the cost of some performance on Android
	/// versions below 10. See
	/// https://flutter.dev/docs/development/platform-integration/platform-views#performance for more
	/// information.
	///
	/// If set to true, the google map widget should be built with
	/// [buildViewWithTextDirection] instead of [buildView].
	///
	/// Defaults to false.
	bool useAndroidViewSurface = false;

	Widget _buildView(
	int creationId,
	PlatformViewCreatedCallback onPlatformViewCreated, {
	required MapWidgetConfiguration widgetConfiguration,
	MapObjects mapObjects = const MapObjects(),
	Map<String, dynamic> mapOptions = const <String, dynamic>{},
	}) {
	final Map<String, dynamic> creationParams = <String, dynamic>{
	'initialCameraPosition':
	widgetConfiguration.initialCameraPosition.toMap(),
	'options': mapOptions,
	'markersToAdd': serializeMarkerSet(mapObjects.markers),
	'polygonsToAdd': serializePolygonSet(mapObjects.polygons),
	'polylinesToAdd': serializePolylineSet(mapObjects.polylines),
	'circlesToAdd': serializeCircleSet(mapObjects.circles),
	'tileOverlaysToAdd': serializeTileOverlaySet(mapObjects.tileOverlays),
	};

	if (defaultTargetPlatform == TargetPlatform.android) {
	if (useAndroidViewSurface) {
	return PlatformViewLink(
	viewType: 'plugins.flutter.io/google_maps',
	surfaceFactory: (
	BuildContext context,
	PlatformViewController controller,
	) {
	return AndroidViewSurface(
	controller: controller as AndroidViewController,
	gestureRecognizers: widgetConfiguration.gestureRecognizers,
	hitTestBehavior: PlatformViewHitTestBehavior.opaque,
	);
	},
	onCreatePlatformView: (PlatformViewCreationParams params) {
	final SurfaceAndroidViewController controller =
	PlatformViewsService.initSurfaceAndroidView(
	id: params.id,
	viewType: 'plugins.flutter.io/google_maps',
	layoutDirection: widgetConfiguration.textDirection,
	creationParams: creationParams,
	creationParamsCodec: const StandardMessageCodec(),
	onFocus: () => params.onFocusChanged(true),
	);
	controller.addOnPlatformViewCreatedListener(
	params.onPlatformViewCreated,
	);
	controller.addOnPlatformViewCreatedListener(
	onPlatformViewCreated,
	);

	controller.create();
	return controller;
	},
	);
	} else {
	return AndroidView(
	viewType: 'plugins.flutter.io/google_maps',
	onPlatformViewCreated: onPlatformViewCreated,
	gestureRecognizers: widgetConfiguration.gestureRecognizers,
	creationParams: creationParams,
	creationParamsCodec: const StandardMessageCodec(),
	);
	}
	} else if (defaultTargetPlatform == TargetPlatform.iOS) {
	return UiKitView(
	viewType: 'plugins.flutter.io/google_maps',
	onPlatformViewCreated: onPlatformViewCreated,
	gestureRecognizers: widgetConfiguration.gestureRecognizers,
	creationParams: creationParams,
	creationParamsCodec: const StandardMessageCodec(),
	);
	}

	return Text(
	'$defaultTargetPlatform is not yet supported by the maps plugin');
	}

	@override
	Widget buildViewWithConfiguration(
	int creationId,
	PlatformViewCreatedCallback onPlatformViewCreated, {
	required MapWidgetConfiguration widgetConfiguration,
	MapConfiguration mapConfiguration = const MapConfiguration(),
	MapObjects mapObjects = const MapObjects(),
	}) {
	return _buildView(
	creationId,
	onPlatformViewCreated,
	widgetConfiguration: widgetConfiguration,
	mapObjects: mapObjects,
	mapOptions: jsonForMapConfiguration(mapConfiguration),
	);
	}

	@override
	Widget buildViewWithTextDirection(
	int creationId,
	PlatformViewCreatedCallback onPlatformViewCreated, {
	required CameraPosition initialCameraPosition,
	required TextDirection textDirection,
	Set<Marker> markers = const <Marker>{},
	Set<Polygon> polygons = const <Polygon>{},
	Set<Polyline> polylines = const <Polyline>{},
	Set<Circle> circles = const <Circle>{},
	Set<TileOverlay> tileOverlays = const <TileOverlay>{},
	Set<Factory<OneSequenceGestureRecognizer>>? gestureRecognizers,
	Map<String, dynamic> mapOptions = const <String, dynamic>{},
	}) {
	return _buildView(
	creationId,
	onPlatformViewCreated,
	widgetConfiguration: MapWidgetConfiguration(
	initialCameraPosition: initialCameraPosition,
	textDirection: textDirection),
	mapObjects: MapObjects(
	markers: markers,
	polygons: polygons,
	polylines: polylines,
	circles: circles,
	tileOverlays: tileOverlays),
	mapOptions: mapOptions,
	);
	}

	@override
	Widget buildView(
	int creationId,
	PlatformViewCreatedCallback onPlatformViewCreated, {
	required CameraPosition initialCameraPosition,
	Set<Marker> markers = const <Marker>{},
	Set<Polygon> polygons = const <Polygon>{},
	Set<Polyline> polylines = const <Polyline>{},
	Set<Circle> circles = const <Circle>{},
	Set<TileOverlay> tileOverlays = const <TileOverlay>{},
	Set<Factory<OneSequenceGestureRecognizer>>? gestureRecognizers,
	Map<String, dynamic> mapOptions = const <String, dynamic>{},
	}) {
	return buildViewWithTextDirection(
	creationId,
	onPlatformViewCreated,
	initialCameraPosition: initialCameraPosition,
	textDirection: TextDirection.ltr,
	markers: markers,
	polygons: polygons,
	polylines: polylines,
	circles: circles,
	tileOverlays: tileOverlays,
	gestureRecognizers: gestureRecognizers,
	mapOptions: mapOptions,
	);
	}
	}