[google_maps_flutter] Use structured Pigeon data on iOS

packages/google_maps_flutter/google_maps_flutter_android/test/google_maps_flutter_android_test.dart

@@ -310,43 +310,32 @@ void main() {
     // Object two should be changed.
     {
       expect(toChange.length, 1);
-      final List<Object?>? encoded = toChange.first.encode() as List<Object?>?;
-      expect(encoded?.getRange(0, 6), <Object?>[
-        object2new.consumeTapEvents,
-        object2new.fillColor.value,
-        object2new.strokeColor.value,
-        object2new.visible,
-        object2new.strokeWidth,
-        object2new.zIndex.toDouble(),
-      ]);
-      final PlatformLatLng? latLng = encoded?[6] as PlatformLatLng?;
-      expect(latLng?.latitude, object2new.center.latitude);
-      expect(latLng?.longitude, object2new.center.longitude);
-      expect(encoded?.getRange(7, 9), <Object?>[
-        object2new.radius,
-        object2new.circleId.value,
-      ]);
+      final PlatformCircle firstChanged = toChange.first;
+      expect(firstChanged.consumeTapEvents, object2new.consumeTapEvents);
+      expect(firstChanged.fillColor, object2new.fillColor.value);
+      expect(firstChanged.strokeColor, object2new.strokeColor.value);
+      expect(firstChanged.visible, object2new.visible);
+      expect(firstChanged.strokeWidth, object2new.strokeWidth);
+      expect(firstChanged.zIndex, object2new.zIndex.toDouble());
+      expect(firstChanged.center.latitude, object2new.center.latitude);
+      expect(firstChanged.center.longitude, object2new.center.longitude);
+      expect(firstChanged.radius, object2new.radius);
+      expect(firstChanged.circleId, object2new.circleId.value);
     }
     // Object 3 should be added.
-    expect(toAdd.length, 1);
     {
       expect(toAdd.length, 1);
-      final List<Object?>? encoded = toAdd.first.encode() as List<Object?>?;
-      expect(encoded?.getRange(0, 6), <Object?>[
-        object3.consumeTapEvents,
-        object3.fillColor.value,
-        object3.strokeColor.value,
-        object3.visible,
-        object3.strokeWidth,
-        object3.zIndex.toDouble(),
-      ]);
-      final PlatformLatLng? latLng = encoded?[6] as PlatformLatLng?;
-      expect(latLng?.latitude, object3.center.latitude);
-      expect(latLng?.longitude, object3.center.longitude);
-      expect(encoded?.getRange(7, 9), <Object?>[
-        object3.radius,
-        object3.circleId.value,
-      ]);
+      final PlatformCircle firstAdded = toAdd.first;
+      expect(firstAdded.consumeTapEvents, object3.consumeTapEvents);
+      expect(firstAdded.fillColor, object3.fillColor.value);
+      expect(firstAdded.strokeColor, object3.strokeColor.value);
+      expect(firstAdded.visible, object3.visible);
+      expect(firstAdded.strokeWidth, object3.strokeWidth);
+      expect(firstAdded.zIndex, object3.zIndex.toDouble());
+      expect(firstAdded.center.latitude, object3.center.latitude);
+      expect(firstAdded.center.longitude, object3.center.longitude);
+      expect(firstAdded.radius, object3.radius);
+      expect(firstAdded.circleId, object3.circleId.value);
     }
   });
 
@@ -406,72 +395,58 @@ void main() {
     // Object two should be changed.
     {
       expect(toChange.length, 1);
-      final List<Object?>? encoded = toChange.first.encode() as List<Object?>?;
-      expect(encoded?[0], object2new.alpha);
-      final PlatformDoublePair? offset = encoded?[1] as PlatformDoublePair?;
-      expect(offset?.x, object2new.anchor.dx);
-      expect(offset?.y, object2new.anchor.dy);
-      expect(encoded?.getRange(2, 5).toList(), <Object?>[
-        object2new.consumeTapEvents,
-        object2new.draggable,
-        object2new.flat,
-      ]);
+      final PlatformMarker firstChanged = toChange.first;
+      expect(firstChanged.alpha, object2new.alpha);
+      expect(firstChanged.anchor.x, object2new.anchor.dx);
+      expect(firstChanged.anchor.y, object2new.anchor.dy);
+      expect(firstChanged.consumeTapEvents, object2new.consumeTapEvents);
+      expect(firstChanged.draggable, object2new.draggable);
+      expect(firstChanged.flat, object2new.flat);
       expect(
-          (encoded?[5] as PlatformBitmap?)?.bitmap.runtimeType,
+          firstChanged.icon.bitmap.runtimeType,
           GoogleMapsFlutterAndroid.platformBitmapFromBitmapDescriptor(
                   object2new.icon)
               .bitmap
               .runtimeType);
-      final PlatformInfoWindow? window = encoded?[6] as PlatformInfoWindow?;
-      expect(window?.title, object2new.infoWindow.title);
-      expect(window?.snippet, object2new.infoWindow.snippet);
-      expect(window?.anchor.x, object2new.infoWindow.anchor.dx);
-      expect(window?.anchor.y, object2new.infoWindow.anchor.dy);
-      final PlatformLatLng? latLng = encoded?[7] as PlatformLatLng?;
-      expect(latLng?.latitude, object2new.position.latitude);
-      expect(latLng?.longitude, object2new.position.longitude);
-      expect(encoded?.getRange(8, 13), <Object?>[
-        object2new.rotation,
-        object2new.visible,
-        object2new.zIndex,
-        object2new.markerId.value,
-        object2new.clusterManagerId?.value,
-      ]);
+      expect(firstChanged.infoWindow.title, object2new.infoWindow.title);
+      expect(firstChanged.infoWindow.snippet, object2new.infoWindow.snippet);
+      expect(firstChanged.infoWindow.anchor.x, object2new.infoWindow.anchor.dx);
+      expect(firstChanged.infoWindow.anchor.y, object2new.infoWindow.anchor.dy);
+      expect(firstChanged.position.latitude, object2new.position.latitude);
+      expect(firstChanged.position.longitude, object2new.position.longitude);
+      expect(firstChanged.rotation, object2new.rotation);
+      expect(firstChanged.visible, object2new.visible);
+      expect(firstChanged.zIndex, object2new.zIndex);
+      expect(firstChanged.markerId, object2new.markerId.value);
+      expect(firstChanged.clusterManagerId, object2new.clusterManagerId?.value);
     }
     // Object 3 should be added.
     {
       expect(toAdd.length, 1);
-      final List<Object?>? encoded = toAdd.first.encode() as List<Object?>?;
-      expect(encoded?[0], object3.alpha);
-      final PlatformDoublePair? offset = encoded?[1] as PlatformDoublePair?;
-      expect(offset?.x, object3.anchor.dx);
-      expect(offset?.y, object3.anchor.dy);
-      expect(encoded?.getRange(2, 5).toList(), <Object?>[
-        object3.consumeTapEvents,
-        object3.draggable,
-        object3.flat,
-      ]);
+      final PlatformMarker firstAdded = toAdd.first;
+      expect(firstAdded.alpha, object3.alpha);
+      expect(firstAdded.anchor.x, object3.anchor.dx);
+      expect(firstAdded.anchor.y, object3.anchor.dy);
+      expect(firstAdded.consumeTapEvents, object3.consumeTapEvents);
+      expect(firstAdded.draggable, object3.draggable);
+      expect(firstAdded.flat, object3.flat);
       expect(
-          (encoded?[5] as PlatformBitmap?)?.bitmap.runtimeType,
+          firstAdded.icon.bitmap.runtimeType,
           GoogleMapsFlutterAndroid.platformBitmapFromBitmapDescriptor(
                   object3.icon)
               .bitmap
               .runtimeType);
-      final PlatformInfoWindow? window = encoded?[6] as PlatformInfoWindow?;
-      expect(window?.title, object3.infoWindow.title);
-      expect(window?.snippet, object3.infoWindow.snippet);
-      expect(window?.anchor.x, object3.infoWindow.anchor.dx);
-      expect(window?.anchor.y, object3.infoWindow.anchor.dy);
-      final PlatformLatLng? latLng = encoded?[7] as PlatformLatLng?;
-      expect(latLng?.latitude, object3.position.latitude);
-      expect(latLng?.longitude, object3.position.longitude);
-      expect(encoded?.getRange(8, 13), <Object?>[
-        object3.rotation,
-        object3.visible,
-        object3.zIndex,
-        object3.markerId.value,
-        object3.clusterManagerId?.value,
-      ]);
+      expect(firstAdded.infoWindow.title, object3.infoWindow.title);
+      expect(firstAdded.infoWindow.snippet, object3.infoWindow.snippet);
+      expect(firstAdded.infoWindow.anchor.x, object3.infoWindow.anchor.dx);
+      expect(firstAdded.infoWindow.anchor.y, object3.infoWindow.anchor.dy);
+      expect(firstAdded.position.latitude, object3.position.latitude);
+      expect(firstAdded.position.longitude, object3.position.longitude);
+      expect(firstAdded.rotation, object3.rotation);
+      expect(firstAdded.visible, object3.visible);
+      expect(firstAdded.zIndex, object3.zIndex);
+      expect(firstAdded.markerId, object3.markerId.value);
+      expect(firstAdded.clusterManagerId, object3.clusterManagerId?.value);
     }
   });
 
@@ -500,17 +475,14 @@ void main() {
     expect(toRemove.length, 1);
     expect(toRemove.first, object1.polygonId.value);
     void expectPolygon(PlatformPolygon actual, Polygon expected) {
-      final List<Object?> encoded = actual.encode() as List<Object?>;
-      expect(encoded.sublist(0, 4), <Object>[
-        expected.polygonId.value,
-        expected.consumeTapEvents,
-        expected.fillColor.value,
-        expected.geodesic,
-      ]);
+      expect(actual.polygonId, expected.polygonId.value);
+      expect(actual.consumesTapEvents, expected.consumeTapEvents);
+      expect(actual.fillColor, expected.fillColor.value);
+      expect(actual.geodesic, expected.geodesic);
       expect(actual.points.length, expected.points.length);
       for (final (int i, PlatformLatLng? point) in actual.points.indexed) {
-        expect(point?.latitude, actual.points[i].latitude);
-        expect(point?.longitude, actual.points[i].longitude);
+        expect(point?.latitude, expected.points[i].latitude);
+        expect(point?.longitude, expected.points[i].longitude);
       }
       expect(actual.holes.length, expected.holes.length);
       for (final (int i, List<PlatformLatLng>? hole) in actual.holes.indexed) {
@@ -520,12 +492,10 @@ void main() {
           expect(point?.longitude, expectedHole[j].longitude);
         }
       }
-      expect(encoded.sublist(6), <Object>[
-        expected.visible,
-        expected.strokeColor.value,
-        expected.strokeWidth,
-        expected.zIndex,
-      ]);
+      expect(actual.visible, expected.visible);
+      expect(actual.strokeColor, expected.strokeColor.value);
+      expect(actual.strokeWidth, expected.strokeWidth);
+      expect(actual.zIndex, expected.zIndex);
     }
 
     // Object two should be changed.
@@ -564,19 +534,15 @@ void main() {
         verification.captured[1] as List<PlatformPolyline>;
     final List<String> toRemove = verification.captured[2] as List<String>;
     void expectPolyline(PlatformPolyline actual, Polyline expected) {
-      final List<Object?> encoded = actual.encode() as List<Object?>;
-      expect(encoded.sublist(0, 5), <Object?>[
-        expected.polylineId.value,
-        expected.consumeTapEvents,
-        expected.color.value,
-        expected.geodesic,
-        platformJointTypeFromJointType(expected.jointType),
-      ]);
-      expect(encoded.sublist(9), <Object?>[
-        expected.visible,
-        expected.width,
-        expected.zIndex,
-      ]);
+      expect(actual.polylineId, expected.polylineId.value);
+      expect(actual.consumesTapEvents, expected.consumeTapEvents);
+      expect(actual.color, expected.color.value);
+      expect(actual.geodesic, expected.geodesic);
+      expect(
+          actual.jointType, platformJointTypeFromJointType(expected.jointType));
+      expect(actual.visible, expected.visible);
+      expect(actual.width, expected.width);
+      expect(actual.zIndex, expected.zIndex);
       expect(actual.points.length, expected.points.length);
       for (final (int i, PlatformLatLng? point) in actual.points.indexed) {
         expect(point?.latitude, actual.points[i].latitude);
@@ -639,15 +605,13 @@ void main() {
     final List<PlatformTileOverlay> toChange =
         verification.captured[1] as List<PlatformTileOverlay>;
     final List<String> toRemove = verification.captured[2] as List<String>;
-    void expectTileOverlay(PlatformTileOverlay? actual, TileOverlay expected) {
-      expect(actual?.encode(), <Object?>[
-        expected.tileOverlayId.value,
-        expected.fadeIn,
-        expected.transparency,
-        expected.zIndex,
-        expected.visible,
-        expected.tileSize,
-      ]);
+    void expectTileOverlay(PlatformTileOverlay actual, TileOverlay expected) {
+      expect(actual.tileOverlayId, expected.tileOverlayId.value);
+      expect(actual.fadeIn, expected.fadeIn);
+      expect(actual.transparency, expected.transparency);
+      expect(actual.zIndex, expected.zIndex);
+      expect(actual.visible, expected.visible);
+      expect(actual.tileSize, expected.tileSize);
     }
 
     // Object one should be removed.

packages/google_maps_flutter/google_maps_flutter_ios/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.13.2
+
+* Updates most objects passed from Dart to native to use typed data.
+
 ## 2.13.1
 
 * Updates Pigeon for non-nullable collection type support.