diff --git a/packages/google_maps_flutter/CHANGELOG.md b/packages/google_maps_flutter/CHANGELOG.md
index a1c829d5c..5d08f620e 100644
--- a/packages/google_maps_flutter/CHANGELOG.md
+++ b/packages/google_maps_flutter/CHANGELOG.md
@@ -1,3 +1,13 @@
+## 0.1.7
+
+* Update webview_flutter_lwe to 0.3.2.
+* Update google_maps_flutter to 2.7.0.
+* Update google_maps_flutter_platform_interface to 2.7.0.
+* Update example code.
+* Supports BitmapDescriptor.asset/bytes.
+* Supports byte type marker icons.
+* Update integration test.
+
 ## 0.1.6
 
 * Fix new lint warnings.
diff --git a/packages/google_maps_flutter/README.md b/packages/google_maps_flutter/README.md
index cbb2abde5..f23b83482 100644
--- a/packages/google_maps_flutter/README.md
+++ b/packages/google_maps_flutter/README.md
@@ -20,8 +20,8 @@ This package is not an _endorsed_ implementation of `google_maps_flutter`. There
 
 ```yaml
 dependencies:
-  google_maps_flutter: ^2.1.7
-  google_maps_flutter_tizen: ^0.1.6
+  google_maps_flutter: ^2.7.0
+  google_maps_flutter_tizen: ^0.1.7
 ```
 
 For detailed usage, see https://pub.dev/packages/google_maps_flutter#sample-usage.
@@ -31,3 +31,9 @@ In addition, you need a Maps JavaScript API Key to use this plugin. You can get
 ```js
 <script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY">
 ```
+
+## Limitations
+
+- This plugin was implemented using the [Google JavaScript API](https://developers.google.com/maps/documentation/javascript/overview).
+The Marker feature uses the [Legacy API](https://developers.google.com/maps/documentation/javascript/markers). Depending on the Deprecate plan of the JavaScript API, some parts may not work.
+- The [marker clustering feature](https://pub.dev/packages/google_maps_flutter_platform_interface/changelog#260) is not yet supported.
diff --git a/packages/google_maps_flutter/example/integration_test/google_maps_test.dart b/packages/google_maps_flutter/example/integration_test/google_maps_test.dart
index efbe7d850..eaa901f5f 100644
--- a/packages/google_maps_flutter/example/integration_test/google_maps_test.dart
+++ b/packages/google_maps_flutter/example/integration_test/google_maps_test.dart
@@ -2,594 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import 'dart:async';
-
-import 'package:flutter/material.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:google_maps_flutter/google_maps_flutter.dart';
-import 'package:google_maps_flutter_platform_interface/google_maps_flutter_platform_interface.dart';
-import 'package:google_maps_flutter_tizen/google_maps_flutter_tizen.dart';
 import 'package:integration_test/integration_test.dart';
 
-const LatLng _kInitialMapCenter = LatLng(0, 0);
-const double _kInitialZoomLevel = 5;
-const CameraPosition _kInitialCameraPosition =
-    CameraPosition(target: _kInitialMapCenter, zoom: _kInitialZoomLevel);
+import 'src/maps_controller.dart' as maps_controller;
+// import 'src/maps_inspector.dart' as maps_inspector;
+// import 'src/tiles_inspector.dart' as tiles_inspector;
 
+/// Recombine all test files in `src` into a single test app.
+///
+/// This is done to ensure that all the integration tests run in the same FTL app,
+/// rather than spinning multiple different tasks.
 void main() {
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();
 
-  testWidgets('updateMinMaxZoomLevels', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    late GoogleMapsPlugin plugin;
-    final Completer<int> mapIdCompleter = Completer<int>();
-
-    const MinMaxZoomPreference initialZoomLevel = MinMaxZoomPreference(4, 8);
-    const MinMaxZoomPreference finalZoomLevel = MinMaxZoomPreference(6, 10);
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        minMaxZoomPreference: initialZoomLevel,
-        onMapCreated: (GoogleMapController c) {
-          mapIdCompleter.complete(c.mapId);
-        },
-      ),
-    ));
-    final int mapId = await mapIdCompleter.future;
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    plugin = GoogleMapsFlutterPlatform.instance as GoogleMapsPlugin;
-    final GoogleMapsController? map = plugin.debugGetMapById(mapId);
-    expect(map, isNotNull);
-
-    MinMaxZoomPreference zoomLevel = await map!.getMinMaxZoomLevels();
-    expect(zoomLevel, equals(initialZoomLevel));
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        minMaxZoomPreference: finalZoomLevel,
-        onMapCreated: (GoogleMapController controller) {
-          fail('OnMapCreated should get called only once.');
-        },
-      ),
-    ));
-
-    zoomLevel = await map.getMinMaxZoomLevels();
-    expect(zoomLevel, equals(finalZoomLevel));
-  });
-
-  testWidgets('testZoomGesturesEnabled', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    late GoogleMapsPlugin plugin;
-    final Completer<int> mapIdCompleter = Completer<int>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        zoomGesturesEnabled: false,
-        onMapCreated: (GoogleMapController c) {
-          mapIdCompleter.complete(c.mapId);
-        },
-      ),
-    ));
-    final int mapId = await mapIdCompleter.future;
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    plugin = GoogleMapsFlutterPlatform.instance as GoogleMapsPlugin;
-    final GoogleMapsController? map = plugin.debugGetMapById(mapId);
-    expect(map, isNotNull);
-
-    bool? zoomGesturesEnabled = await map!.isZoomGesturesEnabled();
-    expect(zoomGesturesEnabled, false);
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          fail('OnMapCreated should get called only once.');
-        },
-      ),
-    ));
-
-    zoomGesturesEnabled = await map.isZoomGesturesEnabled();
-    expect(zoomGesturesEnabled, true);
-  });
-
-  testWidgets('testZoomControlsEnabled', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    late GoogleMapsPlugin plugin;
-    final Completer<int> mapIdCompleter = Completer<int>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController c) {
-          mapIdCompleter.complete(c.mapId);
-        },
-      ),
-    ));
-    final int mapId = await mapIdCompleter.future;
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 2));
-
-    plugin = GoogleMapsFlutterPlatform.instance as GoogleMapsPlugin;
-    final GoogleMapsController? map = plugin.debugGetMapById(mapId);
-    expect(map, isNotNull);
-
-    bool? zoomControlsEnabled = await map!.isZoomControlsEnabled();
-    expect(zoomControlsEnabled, true);
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        zoomControlsEnabled: false,
-        onMapCreated: (GoogleMapController controller) {
-          fail('OnMapCreated should get called only once.');
-        },
-      ),
-    ));
-
-    zoomControlsEnabled = await map.isZoomControlsEnabled();
-    expect(zoomControlsEnabled, false);
-  });
-
-  testWidgets('testScrollGesturesEnabled', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    late GoogleMapsPlugin plugin;
-    final Completer<int> mapIdCompleter = Completer<int>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        scrollGesturesEnabled: false,
-        onMapCreated: (GoogleMapController c) {
-          mapIdCompleter.complete(c.mapId);
-        },
-      ),
-    ));
-    final int mapId = await mapIdCompleter.future;
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    plugin = GoogleMapsFlutterPlatform.instance as GoogleMapsPlugin;
-    final GoogleMapsController? map = plugin.debugGetMapById(mapId);
-    expect(map, isNotNull);
-
-    bool? scrollGesturesEnabled = await map!.isScrollGesturesEnabled();
-    expect(scrollGesturesEnabled, false);
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          fail('OnMapCreated should get called only once.');
-        },
-      ),
-    ));
-
-    scrollGesturesEnabled = await map.isScrollGesturesEnabled();
-    expect(scrollGesturesEnabled, true);
-  });
-
-  testWidgets('testInitialCenterLocationAtCenter', (WidgetTester tester) async {
-    await tester.binding.setSurfaceSize(const Size(800.0, 600.0));
-    final Completer<GoogleMapController> mapControllerCompleter =
-        Completer<GoogleMapController>();
-    final Key key = GlobalKey();
-    await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
-        child: GoogleMap(
-          key: key,
-          initialCameraPosition: _kInitialCameraPosition,
-          onMapCreated: (GoogleMapController controller) {
-            mapControllerCompleter.complete(controller);
-          },
-        ),
-      ),
-    );
-    final GoogleMapController mapController =
-        await mapControllerCompleter.future;
-
-    await tester.pumpAndSettle();
-
-    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
-    // in `mapRendered`.
-    // https://github.com/flutter/flutter/issues/54758
-    await Future<void>.delayed(const Duration(seconds: 1));
-
-    final ScreenCoordinate coordinate =
-        await mapController.getScreenCoordinate(_kInitialCameraPosition.target);
-    final Rect rect = tester.getRect(find.byKey(key));
-
-    // On Tizen, the coordinate value from the GoogleMapSdk doesn't include the devicePixelRatio`.
-    // So we don't need to do the conversion like we did below for other platforms.
-    expect(coordinate.x, (rect.center.dx - rect.topLeft.dx).round());
-    expect(coordinate.y, (rect.center.dy - rect.topLeft.dy).round());
-
-    await tester.binding.setSurfaceSize(null);
-  });
-
-  testWidgets('testGetVisibleRegion', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final LatLngBounds zeroLatLngBounds = LatLngBounds(
-        southwest: const LatLng(0, 0), northeast: const LatLng(0, 0));
-
-    final Completer<GoogleMapController> mapControllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          mapControllerCompleter.complete(controller);
-        },
-      ),
-    ));
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    final GoogleMapController mapController =
-        await mapControllerCompleter.future;
-
-    final LatLngBounds firstVisibleRegion =
-        await mapController.getVisibleRegion();
-
-    expect(firstVisibleRegion, isNotNull);
-    expect(firstVisibleRegion.southwest, isNotNull);
-    expect(firstVisibleRegion.northeast, isNotNull);
-    expect(firstVisibleRegion, isNot(zeroLatLngBounds));
-    expect(firstVisibleRegion.contains(_kInitialMapCenter), isTrue);
-
-    // Making a new `LatLngBounds` about (10, 10) distance south west to the `firstVisibleRegion`.
-    // The size of the `LatLngBounds` is 10 by 10.
-    final LatLng southWest = LatLng(firstVisibleRegion.southwest.latitude - 20,
-        firstVisibleRegion.southwest.longitude - 20);
-    final LatLng northEast = LatLng(firstVisibleRegion.southwest.latitude - 10,
-        firstVisibleRegion.southwest.longitude - 10);
-    final LatLng newCenter = LatLng(
-      (northEast.latitude + southWest.latitude) / 2,
-      (northEast.longitude + southWest.longitude) / 2,
-    );
-
-    expect(firstVisibleRegion.contains(northEast), isFalse);
-    expect(firstVisibleRegion.contains(southWest), isFalse);
-
-    final LatLngBounds latLngBounds =
-        LatLngBounds(southwest: southWest, northeast: northEast);
-
-    // TODO(iskakaushik): non-zero padding is needed for some device configurations
-    // https://github.com/flutter/flutter/issues/30575
-    const double padding = 0;
-    await mapController
-        .moveCamera(CameraUpdate.newLatLngBounds(latLngBounds, padding));
-    // await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    final LatLngBounds secondVisibleRegion =
-        await mapController.getVisibleRegion();
-
-    expect(secondVisibleRegion, isNotNull);
-    expect(secondVisibleRegion.southwest, isNotNull);
-    expect(secondVisibleRegion.northeast, isNotNull);
-    expect(secondVisibleRegion, isNot(zeroLatLngBounds));
-
-    expect(firstVisibleRegion, isNot(secondVisibleRegion));
-    expect(secondVisibleRegion.contains(newCenter), isTrue);
-  });
-
-  testWidgets('testTraffic', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    late GoogleMapsPlugin plugin;
-    final Completer<int> mapIdCompleter = Completer<int>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        trafficEnabled: true,
-        onMapCreated: (GoogleMapController c) {
-          mapIdCompleter.complete(c.mapId);
-        },
-      ),
-    ));
-    final int mapId = await mapIdCompleter.future;
-    await tester.pumpAndSettle();
-    await tester.pumpAndSettle(const Duration(seconds: 3));
-
-    plugin = GoogleMapsFlutterPlatform.instance as GoogleMapsPlugin;
-    final GoogleMapsController? map = plugin.debugGetMapById(mapId);
-    expect(map, isNotNull);
-
-    bool? isTrafficEnabled = await map!.isTrafficEnabled();
-    expect(isTrafficEnabled, true);
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          fail('OnMapCreated should get called only once.');
-        },
-      ),
-    ));
-
-    isTrafficEnabled = await map.isTrafficEnabled();
-    expect(isTrafficEnabled, false);
-  });
-
-  testWidgets('testSetMapStyle valid Json String', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-    const String mapStyle =
-        '[{"elementType":"geometry","stylers":[{"color":"#242f3e"}]}]';
-    await controller.setMapStyle(mapStyle);
-  });
-
-  testWidgets('testSetMapStyle invalid Json String',
-      (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    try {
-      await controller.setMapStyle('invalid_value');
-      fail('expected MapStyleException');
-    } on MapStyleException catch (e) {
-      expect(e.cause, isNotNull);
-    }
-  });
-
-  testWidgets('testSetMapStyle null string', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-    await controller.setMapStyle(null);
-  });
-
-  testWidgets('testGetLatLng', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    await tester.pumpAndSettle();
-    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
-    // in `mapRendered`.
-    // https://github.com/flutter/flutter/issues/54758
-    await Future<void>.delayed(const Duration(seconds: 3));
-
-    final LatLngBounds visibleRegion = await controller.getVisibleRegion();
-    final LatLng topLeft =
-        await controller.getLatLng(const ScreenCoordinate(x: 0, y: 0));
-    final LatLng northWest = LatLng(
-      visibleRegion.northeast.latitude,
-      visibleRegion.southwest.longitude,
-    );
-
-    expect(topLeft, northWest);
-  });
-
-  testWidgets('testGetZoomLevel', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    await tester.pumpAndSettle();
-    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
-    // in `mapRendered`.
-    // https://github.com/flutter/flutter/issues/54758
-    await Future<void>.delayed(const Duration(seconds: 3));
-
-    double zoom = await controller.getZoomLevel();
-    expect(zoom, _kInitialZoomLevel);
-
-    await controller.moveCamera(CameraUpdate.zoomTo(7));
-    await tester.pumpAndSettle();
-    zoom = await controller.getZoomLevel();
-    expect(zoom, equals(7));
-  });
-
-  testWidgets('testScreenCoordinate', (WidgetTester tester) async {
-    final Key key = GlobalKey();
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        key: key,
-        initialCameraPosition: _kInitialCameraPosition,
-        onMapCreated: (GoogleMapController controller) {
-          controllerCompleter.complete(controller);
-        },
-      ),
-    ));
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    await tester.pumpAndSettle();
-    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
-    // in `mapRendered`.
-    // https://github.com/flutter/flutter/issues/54758
-    await Future<void>.delayed(const Duration(seconds: 3));
-
-    final LatLngBounds visibleRegion = await controller.getVisibleRegion();
-    final LatLng northWest = LatLng(
-      visibleRegion.northeast.latitude,
-      visibleRegion.southwest.longitude,
-    );
-    final ScreenCoordinate topLeft =
-        await controller.getScreenCoordinate(northWest);
-    expect(topLeft, const ScreenCoordinate(x: 0, y: 0));
-  });
-
-  testWidgets('testResizeWidget', (WidgetTester tester) async {
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-    final GoogleMap map = GoogleMap(
-      initialCameraPosition: _kInitialCameraPosition,
-      onMapCreated: (GoogleMapController controller) async {
-        controllerCompleter.complete(controller);
-      },
-    );
-    await tester.pumpWidget(Directionality(
-        textDirection: TextDirection.ltr,
-        child: MaterialApp(
-            home: Scaffold(
-                body: SizedBox(height: 100, width: 100, child: map)))));
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    await tester.pumpWidget(Directionality(
-        textDirection: TextDirection.ltr,
-        child: MaterialApp(
-            home: Scaffold(
-                body: SizedBox(height: 400, width: 400, child: map)))));
-
-    await tester.pumpAndSettle();
-    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
-    // in `mapRendered`.
-    // https://github.com/flutter/flutter/issues/54758
-    await Future<void>.delayed(const Duration(seconds: 3));
-
-    // Simple call to make sure that the app hasn't crashed.
-    final LatLngBounds bounds1 = await controller.getVisibleRegion();
-    final LatLngBounds bounds2 = await controller.getVisibleRegion();
-    expect(bounds1, bounds2);
-  });
-
-  testWidgets('testToggleInfoWindow', (WidgetTester tester) async {
-    const Marker marker = Marker(
-        markerId: MarkerId('marker'),
-        infoWindow: InfoWindow(title: 'InfoWindow'));
-    final Set<Marker> markers = <Marker>{marker};
-
-    final Completer<GoogleMapController> controllerCompleter =
-        Completer<GoogleMapController>();
-
-    await tester.pumpWidget(Directionality(
-      textDirection: TextDirection.ltr,
-      child: GoogleMap(
-        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
-        markers: markers,
-        onMapCreated: (GoogleMapController googleMapController) {
-          controllerCompleter.complete(googleMapController);
-        },
-      ),
-    ));
-
-    final GoogleMapController controller = await controllerCompleter.future;
-
-    bool iwVisibleStatus =
-        await controller.isMarkerInfoWindowShown(marker.markerId);
-    expect(iwVisibleStatus, false);
-
-    await controller.showMarkerInfoWindow(marker.markerId);
-    iwVisibleStatus = await controller.isMarkerInfoWindowShown(marker.markerId);
-    expect(iwVisibleStatus, true);
-
-    await controller.hideMarkerInfoWindow(marker.markerId);
-    iwVisibleStatus = await controller.isMarkerInfoWindowShown(marker.markerId);
-    expect(iwVisibleStatus, false);
-  });
-
-  testWidgets('fromAssetImage', (WidgetTester tester) async {
-    const double pixelRatio = 2;
-    const ImageConfiguration imageConfiguration =
-        ImageConfiguration(devicePixelRatio: pixelRatio);
-    final BitmapDescriptor mip = await BitmapDescriptor.fromAssetImage(
-        imageConfiguration, 'red_square.png');
-    final BitmapDescriptor scaled = await BitmapDescriptor.fromAssetImage(
-        imageConfiguration, 'red_square.png',
-        mipmaps: false);
-    expect((mip.toJson() as List<dynamic>)[2], 1);
-    expect((scaled.toJson() as List<dynamic>)[2], 2);
-  });
+  maps_controller.runTests();
+  // In Tizen, GoogleMapsInspectorPlatform does not implemented.
+  // maps_inspector.runTests();
+  // tiles_inspector.runTests();
 }
diff --git a/packages/google_maps_flutter/example/integration_test/src/maps_controller.dart b/packages/google_maps_flutter/example/integration_test/src/maps_controller.dart
new file mode 100644
index 000000000..b5436965f
--- /dev/null
+++ b/packages/google_maps_flutter/example/integration_test/src/maps_controller.dart
@@ -0,0 +1,608 @@
+// 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';
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+import 'package:integration_test/integration_test.dart';
+
+import 'resources/icon_image_base64.dart';
+import 'shared.dart';
+
+/// Integration Tests that only need a standard [GoogleMapController].
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  runTests();
+}
+
+void runTests() {
+  testWidgets(
+    'testInitialCenterLocationAtCenter',
+    (WidgetTester tester) async {
+      await tester.binding.setSurfaceSize(const Size(800, 600));
+
+      final Completer<GoogleMapController> mapControllerCompleter =
+          Completer<GoogleMapController>();
+      final Key key = GlobalKey();
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: GoogleMap(
+            key: key,
+            initialCameraPosition: kInitialCameraPosition,
+            onMapCreated: (GoogleMapController controller) {
+              mapControllerCompleter.complete(controller);
+            },
+          ),
+        ),
+      );
+      final GoogleMapController mapController =
+          await mapControllerCompleter.future;
+
+      await tester.pumpAndSettle();
+
+      // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
+      // in `mapRendered`.
+      // https://github.com/flutter/flutter/issues/54758
+      await Future<void>.delayed(const Duration(seconds: 1));
+
+      final ScreenCoordinate coordinate = await mapController
+          .getScreenCoordinate(kInitialCameraPosition.target);
+      final Rect rect = tester.getRect(find.byKey(key));
+      if (isIOS || isWeb) {
+        // On iOS, the coordinate value from the GoogleMapSdk doesn't include the devicePixelRatio`.
+        // So we don't need to do the conversion like we did below for other platforms.
+        expect(coordinate.x, (rect.center.dx - rect.topLeft.dx).round());
+        expect(coordinate.y, (rect.center.dy - rect.topLeft.dy).round());
+      } else {
+        expect(
+            coordinate.x,
+            ((rect.center.dx - rect.topLeft.dx) * tester.view.devicePixelRatio)
+                .round());
+        expect(
+            coordinate.y,
+            ((rect.center.dy - rect.topLeft.dy) * tester.view.devicePixelRatio)
+                .round());
+      }
+      await tester.binding.setSurfaceSize(null);
+    },
+    // In Tizen, the pixel ratio varies depending on the profile. Therefore, this test cannot operate normally.
+    skip: true,
+  );
+
+  testWidgets('testGetVisibleRegion', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final LatLngBounds zeroLatLngBounds = LatLngBounds(
+        southwest: const LatLng(0, 0), northeast: const LatLng(0, 0));
+
+    final Completer<GoogleMapController> mapControllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          mapControllerCompleter.complete(controller);
+        },
+      ),
+    );
+    await tester.pumpAndSettle(const Duration(seconds: 3));
+    final GoogleMapController mapController =
+        await mapControllerCompleter.future;
+
+    // Wait for the visible region to be non-zero.
+    final LatLngBounds firstVisibleRegion =
+        await waitForValueMatchingPredicate<LatLngBounds>(
+                tester,
+                () => mapController.getVisibleRegion(),
+                (LatLngBounds bounds) => bounds != zeroLatLngBounds) ??
+            zeroLatLngBounds;
+    expect(firstVisibleRegion, isNot(zeroLatLngBounds));
+    expect(firstVisibleRegion.contains(kInitialMapCenter), isTrue);
+
+    // Making a new `LatLngBounds` about (10, 10) distance south west to the `firstVisibleRegion`.
+    // The size of the `LatLngBounds` is 10 by 10.
+    final LatLng southWest = LatLng(firstVisibleRegion.southwest.latitude - 20,
+        firstVisibleRegion.southwest.longitude - 20);
+    final LatLng northEast = LatLng(firstVisibleRegion.southwest.latitude - 10,
+        firstVisibleRegion.southwest.longitude - 10);
+    final LatLng newCenter = LatLng(
+      (northEast.latitude + southWest.latitude) / 2,
+      (northEast.longitude + southWest.longitude) / 2,
+    );
+
+    expect(firstVisibleRegion.contains(northEast), isFalse);
+    expect(firstVisibleRegion.contains(southWest), isFalse);
+
+    final LatLngBounds latLngBounds =
+        LatLngBounds(southwest: southWest, northeast: northEast);
+
+    // TODO(iskakaushik): non-zero padding is needed for some device configurations
+    // https://github.com/flutter/flutter/issues/30575
+    const double padding = 0;
+    await mapController
+        .moveCamera(CameraUpdate.newLatLngBounds(latLngBounds, padding));
+    await tester.pumpAndSettle(const Duration(seconds: 3));
+
+    final LatLngBounds secondVisibleRegion =
+        await mapController.getVisibleRegion();
+
+    expect(secondVisibleRegion, isNot(zeroLatLngBounds));
+
+    expect(firstVisibleRegion, isNot(secondVisibleRegion));
+    expect(secondVisibleRegion.contains(newCenter), isTrue);
+  },
+      // TODO(stuartmorgan): Re-enable; see https://github.com/flutter/flutter/issues/139825
+      skip: isIOS);
+
+  testWidgets('testSetMapStyle valid Json String', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    const String mapStyle =
+        '[{"elementType":"geometry","stylers":[{"color":"#242f3e"}]}]';
+    await controller.setMapStyle(mapStyle);
+  });
+
+  testWidgets('testSetMapStyle invalid Json String',
+      (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    try {
+      await controller.setMapStyle('invalid_value');
+      fail('expected MapStyleException');
+    } on MapStyleException catch (e) {
+      expect(e.cause, isNotNull);
+    }
+  });
+
+  testWidgets('testSetMapStyle null string', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await controller.setMapStyle(null);
+  });
+
+  testWidgets('testGetLatLng', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await tester.pumpAndSettle();
+    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
+    // in `mapRendered`.
+    // https://github.com/flutter/flutter/issues/54758
+    await Future<void>.delayed(const Duration(seconds: 3));
+
+    final LatLngBounds visibleRegion = await controller.getVisibleRegion();
+    final LatLng topLeft =
+        await controller.getLatLng(const ScreenCoordinate(x: 0, y: 0));
+    final LatLng northWest = LatLng(
+      visibleRegion.northeast.latitude,
+      visibleRegion.southwest.longitude,
+    );
+
+    expect(topLeft, northWest);
+  });
+
+  testWidgets('testGetZoomLevel', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await tester.pumpAndSettle();
+    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
+    // in `mapRendered`.
+    // https://github.com/flutter/flutter/issues/54758
+    await Future<void>.delayed(const Duration(seconds: 3));
+
+    double zoom = await controller.getZoomLevel();
+    expect(zoom, kInitialZoomLevel);
+
+    await controller.moveCamera(CameraUpdate.zoomTo(7));
+    await tester.pumpAndSettle();
+    zoom = await controller.getZoomLevel();
+    expect(zoom, equals(7));
+  },
+      // TODO(stuartmorgan): Re-enable; see https://github.com/flutter/flutter/issues/139825
+      skip: isIOS);
+
+  testWidgets('testScreenCoordinate', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await tester.pumpAndSettle();
+    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
+    // in `mapRendered`.
+    // https://github.com/flutter/flutter/issues/54758
+    await Future<void>.delayed(const Duration(seconds: 3));
+
+    final LatLngBounds visibleRegion = await controller.getVisibleRegion();
+    final LatLng northWest = LatLng(
+      visibleRegion.northeast.latitude,
+      visibleRegion.southwest.longitude,
+    );
+    final ScreenCoordinate topLeft =
+        await controller.getScreenCoordinate(northWest);
+    expect(topLeft, const ScreenCoordinate(x: 0, y: 0));
+  },
+      // TODO(stuartmorgan): Re-enable; see https://github.com/flutter/flutter/issues/139825
+      skip: isIOS);
+
+  testWidgets('testResizeWidget', (WidgetTester tester) async {
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) async {
+          controllerCompleter.complete(controller);
+        },
+      ),
+      const Size(100, 100),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) async {
+          // fail!
+          fail('The map should not get recreated!');
+          // controllerCompleter.complete(controller);
+        },
+      ),
+      const Size(400, 400),
+    );
+
+    await tester.pumpAndSettle();
+    // TODO(cyanglaz): Remove this after we added `mapRendered` callback, and `mapControllerCompleter.complete(controller)` above should happen
+    // in `mapRendered`.
+    // https://github.com/flutter/flutter/issues/54758
+    await Future<void>.delayed(const Duration(seconds: 3));
+
+    // Simple call to make sure that the app hasn't crashed.
+    final LatLngBounds bounds1 = await controller.getVisibleRegion();
+    final LatLngBounds bounds2 = await controller.getVisibleRegion();
+    expect(bounds1, bounds2);
+  });
+
+  testWidgets('testToggleInfoWindow', (WidgetTester tester) async {
+    const Marker marker = Marker(
+        markerId: MarkerId('marker'),
+        infoWindow: InfoWindow(title: 'InfoWindow'));
+    final Set<Marker> markers = <Marker>{marker};
+
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+        onMapCreated: (GoogleMapController googleMapController) {
+          controllerCompleter.complete(googleMapController);
+        },
+      ),
+    );
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    await tester.pumpAndSettle();
+
+    // TODO(mossmana): Adding this delay addresses
+    // https://github.com/flutter/flutter/issues/131783. It may be related
+    // to https://github.com/flutter/flutter/issues/54758 and should be
+    // re-evaluated when that issue is fixed.
+    await Future<void>.delayed(const Duration(seconds: 3));
+
+    bool iwVisibleStatus =
+        await controller.isMarkerInfoWindowShown(marker.markerId);
+    expect(iwVisibleStatus, false);
+
+    await controller.showMarkerInfoWindow(marker.markerId);
+    // The Maps SDK doesn't always return true for whether it is shown
+    // immediately after showing it, so wait for it to report as shown.
+    iwVisibleStatus = await waitForValueMatchingPredicate<bool>(
+            tester,
+            () => controller.isMarkerInfoWindowShown(marker.markerId),
+            (bool visible) => visible) ??
+        false;
+    expect(iwVisibleStatus, true);
+
+    await controller.hideMarkerInfoWindow(marker.markerId);
+    iwVisibleStatus = await controller.isMarkerInfoWindowShown(marker.markerId);
+    expect(iwVisibleStatus, false);
+  });
+
+  testWidgets('markerWithAssetMapBitmap', (WidgetTester tester) async {
+    final Set<Marker> markers = <Marker>{
+      Marker(
+          markerId: const MarkerId('1'),
+          icon: AssetMapBitmap(
+            'assets/red_square.png',
+            imagePixelRatio: 1.0,
+          )),
+    };
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+      ),
+    );
+  });
+
+  testWidgets('markerWithAssetMapBitmapCreate', (WidgetTester tester) async {
+    final ImageConfiguration imageConfiguration = ImageConfiguration(
+      devicePixelRatio: tester.view.devicePixelRatio,
+    );
+    final Set<Marker> markers = <Marker>{
+      Marker(
+          markerId: const MarkerId('1'),
+          icon: await AssetMapBitmap.create(
+            imageConfiguration,
+            'assets/red_square.png',
+          )),
+    };
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+      ),
+    );
+  });
+
+  testWidgets('markerWithBytesMapBitmap', (WidgetTester tester) async {
+    final Uint8List bytes = const Base64Decoder().convert(iconImageBase64);
+    final Set<Marker> markers = <Marker>{
+      Marker(
+        markerId: const MarkerId('1'),
+        icon: BytesMapBitmap(
+          bytes,
+          imagePixelRatio: tester.view.devicePixelRatio,
+        ),
+      ),
+    };
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+      ),
+    );
+  });
+
+  testWidgets('markerWithLegacyAsset', (WidgetTester tester) async {
+    tester.view.devicePixelRatio = 2.0;
+    final ImageConfiguration imageConfiguration = ImageConfiguration(
+      devicePixelRatio: tester.view.devicePixelRatio,
+      size: const Size(100, 100),
+    );
+    final Set<Marker> markers = <Marker>{
+      Marker(
+          markerId: const MarkerId('1'),
+          icon: await BitmapDescriptor.fromAssetImage(
+            imageConfiguration,
+            'assets/red_square.png',
+          )),
+    };
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+      ),
+    );
+
+    await tester.pumpAndSettle();
+  });
+
+  testWidgets('markerWithLegacyBytes', (WidgetTester tester) async {
+    tester.view.devicePixelRatio = 2.0;
+    final Uint8List bytes = const Base64Decoder().convert(iconImageBase64);
+    final Set<Marker> markers = <Marker>{
+      Marker(
+          markerId: const MarkerId('1'),
+          icon: BitmapDescriptor.fromBytes(
+            bytes,
+            size: const Size(100, 100),
+          )),
+    };
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: const CameraPosition(target: LatLng(10.0, 15.0)),
+        markers: markers,
+      ),
+    );
+
+    await tester.pumpAndSettle();
+  });
+
+  testWidgets('testTakeSnapshot', (WidgetTester tester) async {
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          controllerCompleter.complete(controller);
+        },
+      ),
+    );
+    await tester.pumpAndSettle(const Duration(seconds: 3));
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    final Uint8List? bytes = await controller.takeSnapshot();
+    expect(bytes?.isNotEmpty, true);
+  },
+      // // In Tizen, TakeSnapshot is not supported.
+      skip: true);
+
+  testWidgets(
+    'testCloudMapId',
+    (WidgetTester tester) async {
+      final Completer<int> mapIdCompleter = Completer<int>();
+      final Key key = GlobalKey();
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          onMapCreated: (GoogleMapController controller) {
+            mapIdCompleter.complete(controller.mapId);
+          },
+          cloudMapId: kCloudMapId,
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      // Await mapIdCompleter to finish to make sure map can be created with cloudMapId
+      await mapIdCompleter.future;
+    },
+    // // In Tizen, CloudMap is not supported.
+    skip: true,
+  );
+
+  testWidgets(
+    'getStyleError reports last error',
+    (WidgetTester tester) async {
+      final Key key = GlobalKey();
+      final Completer<GoogleMapController> controllerCompleter =
+          Completer<GoogleMapController>();
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          style: '[[[this is an invalid style',
+          onMapCreated: (GoogleMapController controller) {
+            controllerCompleter.complete(controller);
+          },
+        ),
+      );
+
+      final GoogleMapController controller = await controllerCompleter.future;
+      final String? error = await controller.getStyleError();
+      expect(error, isNotNull);
+    },
+    // In Tizen, getStyleError() is not implemented.
+    skip: true,
+  );
+}
+
+/// Repeatedly checks an asynchronous value against a test condition.
+///
+/// This function waits one frame between each check, returning the value if it
+/// passes the predicate before [maxTries] is reached.
+///
+/// Returns null if the predicate is never satisfied.
+///
+/// This is useful for cases where the Maps SDK has some internally
+/// asynchronous operation that we don't have visibility into (e.g., native UI
+/// animations).
+Future<T?> waitForValueMatchingPredicate<T>(WidgetTester tester,
+    Future<T> Function() getValue, bool Function(T) predicate,
+    {int maxTries = 100}) async {
+  for (int i = 0; i < maxTries; i++) {
+    final T value = await getValue();
+    if (predicate(value)) {
+      return value;
+    }
+    await tester.pump();
+  }
+  return null;
+}
diff --git a/packages/google_maps_flutter/example/integration_test/src/maps_inspector.dart b/packages/google_maps_flutter/example/integration_test/src/maps_inspector.dart
new file mode 100644
index 000000000..efa4baaea
--- /dev/null
+++ b/packages/google_maps_flutter/example/integration_test/src/maps_inspector.dart
@@ -0,0 +1,536 @@
+// 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';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+import 'package:google_maps_flutter_platform_interface/google_maps_flutter_platform_interface.dart';
+import 'package:integration_test/integration_test.dart';
+
+import 'shared.dart';
+
+/// Integration Tests that use the [GoogleMapsInspectorPlatform].
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  runTests();
+}
+
+void runTests() {
+  GoogleMapsFlutterPlatform.instance.enableDebugInspection();
+
+  final GoogleMapsInspectorPlatform inspector =
+      GoogleMapsInspectorPlatform.instance!;
+
+  testWidgets('testCompassToggle', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        compassEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool compassEnabled = await inspector.isCompassEnabled(mapId: mapId);
+    expect(compassEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    compassEnabled = await inspector.isCompassEnabled(mapId: mapId);
+    expect(compassEnabled, !kIsWeb);
+  });
+
+  testWidgets('testMapToolbarToggle', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        mapToolbarEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool mapToolbarEnabled = await inspector.isMapToolbarEnabled(mapId: mapId);
+    expect(mapToolbarEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    mapToolbarEnabled = await inspector.isMapToolbarEnabled(mapId: mapId);
+    expect(mapToolbarEnabled, isAndroid);
+  });
+
+  testWidgets('updateMinMaxZoomLevels', (WidgetTester tester) async {
+    // The behaviors of setting min max zoom level on iOS and Android are different.
+    // On iOS, when we get the min or max zoom level after setting the preference, the
+    // min and max will be exactly the same as the value we set; on Android however,
+    // the values we get do not equal to the value we set.
+    //
+    // Also, when we call zoomTo to set the zoom, on Android, it usually
+    // honors the preferences that we set and the zoom cannot pass beyond the boundary.
+    // On iOS, on the other hand, zoomTo seems to override the preferences.
+    //
+    // Thus we test iOS and Android a little differently here.
+    final Key key = GlobalKey();
+    final Completer<GoogleMapController> controllerCompleter =
+        Completer<GoogleMapController>();
+
+    const MinMaxZoomPreference initialZoomLevel = MinMaxZoomPreference(4, 8);
+    const MinMaxZoomPreference finalZoomLevel = MinMaxZoomPreference(6, 10);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        minMaxZoomPreference: initialZoomLevel,
+        onMapCreated: (GoogleMapController c) async {
+          controllerCompleter.complete(c);
+        },
+      ),
+    );
+
+    final GoogleMapController controller = await controllerCompleter.future;
+
+    if (isIOS) {
+      final MinMaxZoomPreference zoomLevel =
+          await inspector.getMinMaxZoomLevels(mapId: controller.mapId);
+      expect(zoomLevel, equals(initialZoomLevel));
+    } else if (isAndroid) {
+      await controller.moveCamera(CameraUpdate.zoomTo(15));
+      await tester.pumpAndSettle();
+      double? zoomLevel = await controller.getZoomLevel();
+      expect(zoomLevel, equals(initialZoomLevel.maxZoom));
+
+      await controller.moveCamera(CameraUpdate.zoomTo(1));
+      await tester.pumpAndSettle();
+      zoomLevel = await controller.getZoomLevel();
+      expect(zoomLevel, equals(initialZoomLevel.minZoom));
+    }
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        minMaxZoomPreference: finalZoomLevel,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    if (isIOS) {
+      final MinMaxZoomPreference zoomLevel =
+          await inspector.getMinMaxZoomLevels(mapId: controller.mapId);
+      expect(zoomLevel, equals(finalZoomLevel));
+    } else {
+      await controller.moveCamera(CameraUpdate.zoomTo(15));
+      await tester.pumpAndSettle();
+      double? zoomLevel = await controller.getZoomLevel();
+      expect(zoomLevel, equals(finalZoomLevel.maxZoom));
+
+      await controller.moveCamera(CameraUpdate.zoomTo(1));
+      await tester.pumpAndSettle();
+      zoomLevel = await controller.getZoomLevel();
+      expect(zoomLevel, equals(finalZoomLevel.minZoom));
+    }
+  });
+
+  testWidgets('testZoomGesturesEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        zoomGesturesEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool zoomGesturesEnabled =
+        await inspector.areZoomGesturesEnabled(mapId: mapId);
+    expect(zoomGesturesEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    zoomGesturesEnabled = await inspector.areZoomGesturesEnabled(mapId: mapId);
+    expect(zoomGesturesEnabled, true);
+  });
+
+  testWidgets('testZoomControlsEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool zoomControlsEnabled =
+        await inspector.areZoomControlsEnabled(mapId: mapId);
+    expect(zoomControlsEnabled, !isIOS);
+
+    /// Zoom Controls functionality is not available on iOS at the moment.
+    if (!isIOS) {
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          zoomControlsEnabled: false,
+          onMapCreated: (GoogleMapController controller) {
+            fail('OnMapCreated should get called only once.');
+          },
+        ),
+      );
+
+      zoomControlsEnabled =
+          await inspector.areZoomControlsEnabled(mapId: mapId);
+      expect(zoomControlsEnabled, false);
+    }
+  });
+
+  testWidgets('testLiteModeEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool liteModeEnabled = await inspector.isLiteModeEnabled(mapId: mapId);
+    expect(liteModeEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        liteModeEnabled: true,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    liteModeEnabled = await inspector.isLiteModeEnabled(mapId: mapId);
+    expect(liteModeEnabled, true);
+  }, skip: !isAndroid);
+
+  testWidgets('testRotateGesturesEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        rotateGesturesEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool rotateGesturesEnabled =
+        await inspector.areRotateGesturesEnabled(mapId: mapId);
+    expect(rotateGesturesEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    rotateGesturesEnabled =
+        await inspector.areRotateGesturesEnabled(mapId: mapId);
+    expect(rotateGesturesEnabled, !isWeb);
+  });
+
+  testWidgets('testTiltGesturesEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        tiltGesturesEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool tiltGesturesEnabled =
+        await inspector.areTiltGesturesEnabled(mapId: mapId);
+    expect(tiltGesturesEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    tiltGesturesEnabled = await inspector.areTiltGesturesEnabled(mapId: mapId);
+    expect(tiltGesturesEnabled, !isWeb);
+  });
+
+  testWidgets('testScrollGesturesEnabled', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        scrollGesturesEnabled: false,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool scrollGesturesEnabled =
+        await inspector.areScrollGesturesEnabled(mapId: mapId);
+    expect(scrollGesturesEnabled, false);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    scrollGesturesEnabled =
+        await inspector.areScrollGesturesEnabled(mapId: mapId);
+    expect(scrollGesturesEnabled, true);
+  });
+
+  testWidgets('testTraffic', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        trafficEnabled: true,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    bool isTrafficEnabled = await inspector.isTrafficEnabled(mapId: mapId);
+    expect(isTrafficEnabled, true);
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          fail('OnMapCreated should get called only once.');
+        },
+      ),
+    );
+
+    isTrafficEnabled = await inspector.isTrafficEnabled(mapId: mapId);
+    expect(isTrafficEnabled, false);
+  });
+
+  testWidgets('testBuildings', (WidgetTester tester) async {
+    final Key key = GlobalKey();
+    final Completer<int> mapIdCompleter = Completer<int>();
+
+    await pumpMap(
+      tester,
+      GoogleMap(
+        key: key,
+        initialCameraPosition: kInitialCameraPosition,
+        onMapCreated: (GoogleMapController controller) {
+          mapIdCompleter.complete(controller.mapId);
+        },
+      ),
+    );
+    final int mapId = await mapIdCompleter.future;
+
+    final bool isBuildingsEnabled =
+        await inspector.areBuildingsEnabled(mapId: mapId);
+    expect(isBuildingsEnabled, !isWeb);
+  });
+
+  // Location button tests are skipped in Android because we don't have location permission to test.
+  // Location button tests are skipped in Web because the functionality is not implemented.
+  group('MyLocationButton', () {
+    testWidgets('testMyLocationButtonToggle', (WidgetTester tester) async {
+      final Key key = GlobalKey();
+      final Completer<int> mapIdCompleter = Completer<int>();
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          onMapCreated: (GoogleMapController controller) {
+            mapIdCompleter.complete(controller.mapId);
+          },
+        ),
+      );
+      final int mapId = await mapIdCompleter.future;
+
+      bool myLocationButtonEnabled =
+          await inspector.isMyLocationButtonEnabled(mapId: mapId);
+      expect(myLocationButtonEnabled, true);
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          myLocationButtonEnabled: false,
+          onMapCreated: (GoogleMapController controller) {
+            fail('OnMapCreated should get called only once.');
+          },
+        ),
+      );
+
+      myLocationButtonEnabled =
+          await inspector.isMyLocationButtonEnabled(mapId: mapId);
+      expect(myLocationButtonEnabled, false);
+    });
+
+    testWidgets('testMyLocationButton initial value false',
+        (WidgetTester tester) async {
+      final Key key = GlobalKey();
+      final Completer<int> mapIdCompleter = Completer<int>();
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          myLocationButtonEnabled: false,
+          onMapCreated: (GoogleMapController controller) {
+            mapIdCompleter.complete(controller.mapId);
+          },
+        ),
+      );
+      final int mapId = await mapIdCompleter.future;
+
+      final bool myLocationButtonEnabled =
+          await inspector.isMyLocationButtonEnabled(mapId: mapId);
+      expect(myLocationButtonEnabled, false);
+    });
+
+    testWidgets('testMyLocationButton initial value true',
+        (WidgetTester tester) async {
+      final Key key = GlobalKey();
+      final Completer<int> mapIdCompleter = Completer<int>();
+
+      await pumpMap(
+        tester,
+        GoogleMap(
+          key: key,
+          initialCameraPosition: kInitialCameraPosition,
+          onMapCreated: (GoogleMapController controller) {
+            mapIdCompleter.complete(controller.mapId);
+          },
+        ),
+      );
+      final int mapId = await mapIdCompleter.future;
+
+      final bool myLocationButtonEnabled =
+          await inspector.isMyLocationButtonEnabled(mapId: mapId);
+      expect(myLocationButtonEnabled, true);
+    });
+  }, skip: !isIOS);
+}
diff --git a/packages/google_maps_flutter/example/integration_test/src/resources/icon_image.png b/packages/google_maps_flutter/example/integration_test/src/resources/icon_image.png
new file mode 100644
index 000000000..920b93f74
Binary files /dev/null and b/packages/google_maps_flutter/example/integration_test/src/resources/icon_image.png differ
diff --git a/packages/google_maps_flutter/example/integration_test/src/resources/icon_image_base64.dart b/packages/google_maps_flutter/example/integration_test/src/resources/icon_image_base64.dart
new file mode 100644
index 000000000..1bfc791ca
--- /dev/null
+++ b/packages/google_maps_flutter/example/integration_test/src/resources/icon_image_base64.dart
@@ -0,0 +1,49 @@
+// 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.
+
+/// This constant holds the base64-encoded data of a 16x16 PNG image of the
+/// Flutter logo.
+///
+/// See `icon_image.png` source in the same directory.
+///
+/// To create or update this image, follow these steps:
+/// 1. Create or update a 16x16 PNG image.
+/// 2. Convert the image to a base64 string using a script below.
+/// 3. Replace the existing base64 string below with the new one.
+///
+/// Example of converting an image to base64 in Dart:
+/// ```dart
+/// import 'dart:convert';
+/// import 'dart:io';
+///
+/// void main() async {
+///   final bytes = await File('icon_image.png').readAsBytes();
+///   final base64String = base64Encode(bytes);
+///   print(base64String);
+/// }
+/// ```
+const String iconImageBase64 =
+    'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAIRlWElmTU'
+    '0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIA'
+    'AIdpAAQAAAABAAAAWgAAAAAAAABIAAAAAQAAAEgAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQ'
+    'AAABCgAwAEAAAAAQAAABAAAAAAx28c8QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAVlpVFh0WE1M'
+    'OmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIH'
+    'g6eG1wdGs9IlhNUCBDb3JlIDUuNC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8v'
+    'd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcm'
+    'lwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFk'
+    'b2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpPcmllbnRhdGlvbj4xPC90aWZmOk'
+    '9yaWVudGF0aW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6'
+    'eG1wbWV0YT4KTMInWQAAAplJREFUOBF1k01ME1EQx2fe7tIPoGgTE6AJgQQSPaiH9oAtkFbsgX'
+    'jygFcT0XjSkxcTDxtPJh6MR28ePMHBBA8cNLSIony0oBhEMVETP058tE132+7uG3cW24DAXN57'
+    '2fn9/zPz3iIcEdEl0nIxtNLr1IlVeoMadkubKmoL+u2SzAV8IjV5Ekt4GN+A8+VOUPwLarOI2G'
+    'Vpqq0i4JQorwQxPtWHVZ1IKP8LNGDXGaSyqARFxDGo7MJBy4XVf3AyQ+qTHnTEXoF9cFUy3OkY'
+    '0oWxmWFtD5xNoc1sQ6AOn1+hCNTkkhKow8KFZV77tVs2O9dhFvBm0IA/U0RhZ7/ocEx23oUDlh'
+    'h8HkNjZIN8Lb3gOU8gOp7AKJHCB2/aNZkTftHumNzzbtl2CBPZHqxw8mHhVZBeoz6w5DvhE2FZ'
+    'lQYPjKdd2/qRyKZ6KsPv7TEk7EYEk0A0EUmJduHRy1i4oLKqgmC59ZggAdwrC9pFuWy1iUT2rA'
+    'uv0h2UdNtNqxCBBkgqorjOMOgksN7CxQ90vEb00U3c3LIwyo9o8FXxQVNr8Coqyk+S5EPBXnjt'
+    'xRmc4TegI7qWbvBkeeUbGMnTCd4nZnYeDOWIEtlC6cKK/JJepY3hZSvN33jovO6L0XFqPKqBTO'
+    'FuapUoPr1lxDM7cmC2TAOz25cYSGa++feBew/cjpc0V+mNT29/HZp3KDFTNLvuTRPEHy5065lj'
+    'Xn4y41XM+wP/AlcycRmdc3MUhvLm/J/ceu/3qUVT62oP2EZpjSylHybHSpDUVcjq9gEBVo0+Xt'
+    'JyN2IWRO+3QUforRoKnZLVsglaMECW+YmMSj9M3SrC6Lg71CMiqWfUrJ6ywzefhnZ+G69BaKdB'
+    'WhXQAn6wzDUpfUPw7MrmX/WhbfmKblw+AAAAAElFTkSuQmCC';
diff --git a/packages/google_maps_flutter/example/integration_test/src/shared.dart b/packages/google_maps_flutter/example/integration_test/src/shared.dart
new file mode 100644
index 000000000..126733f67
--- /dev/null
+++ b/packages/google_maps_flutter/example/integration_test/src/shared.dart
@@ -0,0 +1,56 @@
+// 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.
+
+// This file contains shared definitions used across multiple test scenarios.
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+
+/// Initial map center
+const LatLng kInitialMapCenter = LatLng(0, 0);
+
+/// Initial zoom level
+const double kInitialZoomLevel = 5;
+
+/// Initial camera position
+const CameraPosition kInitialCameraPosition =
+    CameraPosition(target: kInitialMapCenter, zoom: kInitialZoomLevel);
+
+// Dummy map ID
+const String kCloudMapId = '000000000000000'; // Dummy map ID.
+
+/// True if the test is running in an iOS device
+final bool isIOS = defaultTargetPlatform == TargetPlatform.iOS;
+
+/// True if the test is running in an Android device
+final bool isAndroid =
+    defaultTargetPlatform == TargetPlatform.android && !kIsWeb;
+
+/// True if the test is running in a web browser.
+const bool isWeb = kIsWeb;
+
+/// Pumps a [map] widget in [tester] of a certain [size], then waits until it settles.
+Future<void> pumpMap(WidgetTester tester, GoogleMap map,
+    [Size size = const Size.square(200)]) async {
+  await tester.pumpWidget(wrapMap(map, size));
+  await tester.pumpAndSettle();
+}
+
+/// Wraps a [map] in a bunch of widgets so it renders in all platforms.
+///
+/// An optional [size] can be passed.
+Widget wrapMap(GoogleMap map, [Size size = const Size.square(200)]) {
+  return MaterialApp(
+    home: Scaffold(
+      body: Center(
+        child: SizedBox.fromSize(
+          size: size,
+          child: map,
+        ),
+      ),
+    ),
+  );
+}
diff --git a/packages/google_maps_flutter/example/integration_test/src/tiles_inspector.dart b/packages/google_maps_flutter/example/integration_test/src/tiles_inspector.dart
new file mode 100644
index 000000000..9c9914d89
--- /dev/null
+++ b/packages/google_maps_flutter/example/integration_test/src/tiles_inspector.dart
@@ -0,0 +1,251 @@
+// 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';
+import 'dart:ui' as ui;
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+import 'package:google_maps_flutter_platform_interface/google_maps_flutter_platform_interface.dart';
+import 'package:integration_test/integration_test.dart';
+
+import 'shared.dart';
+
+/// Integration Tests for the Tiles feature. These also use the [GoogleMapsInspectorPlatform].
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  runTests();
+}
+
+void runTests() {
+  GoogleMapsFlutterPlatform.instance.enableDebugInspection();
+
+  final GoogleMapsInspectorPlatform inspector =
+      GoogleMapsInspectorPlatform.instance!;
+
+  group('Tiles', () {
+    testWidgets(
+      'set tileOverlay correctly',
+      (WidgetTester tester) async {
+        final Completer<int> mapIdCompleter = Completer<int>();
+        final TileOverlay tileOverlay1 = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_1'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 2,
+          transparency: 0.2,
+        );
+
+        final TileOverlay tileOverlay2 = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_2'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 1,
+          visible: false,
+          transparency: 0.3,
+          fadeIn: false,
+        );
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: GoogleMap(
+              initialCameraPosition: kInitialCameraPosition,
+              tileOverlays: <TileOverlay>{tileOverlay1, tileOverlay2},
+              onMapCreated: (GoogleMapController controller) {
+                mapIdCompleter.complete(controller.mapId);
+              },
+            ),
+          ),
+        );
+        await tester.pumpAndSettle(const Duration(seconds: 3));
+
+        final int mapId = await mapIdCompleter.future;
+
+        final TileOverlay tileOverlayInfo1 = (await inspector
+            .getTileOverlayInfo(tileOverlay1.mapsId, mapId: mapId))!;
+        final TileOverlay tileOverlayInfo2 = (await inspector
+            .getTileOverlayInfo(tileOverlay2.mapsId, mapId: mapId))!;
+
+        expect(tileOverlayInfo1.visible, isTrue);
+        expect(tileOverlayInfo1.fadeIn, isTrue);
+        expect(tileOverlayInfo1.transparency,
+            moreOrLessEquals(0.2, epsilon: 0.001));
+        expect(tileOverlayInfo1.zIndex, 2);
+
+        expect(tileOverlayInfo2.visible, isFalse);
+        expect(tileOverlayInfo2.fadeIn, isFalse);
+        expect(tileOverlayInfo2.transparency,
+            moreOrLessEquals(0.3, epsilon: 0.001));
+        expect(tileOverlayInfo2.zIndex, 1);
+      },
+    );
+
+    testWidgets(
+      'update tileOverlays correctly',
+      (WidgetTester tester) async {
+        final Completer<int> mapIdCompleter = Completer<int>();
+        final Key key = GlobalKey();
+        final TileOverlay tileOverlay1 = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_1'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 2,
+          transparency: 0.2,
+        );
+
+        final TileOverlay tileOverlay2 = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_2'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 3,
+          transparency: 0.5,
+        );
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: GoogleMap(
+              key: key,
+              initialCameraPosition: kInitialCameraPosition,
+              tileOverlays: <TileOverlay>{tileOverlay1, tileOverlay2},
+              onMapCreated: (GoogleMapController controller) {
+                mapIdCompleter.complete(controller.mapId);
+              },
+            ),
+          ),
+        );
+
+        final int mapId = await mapIdCompleter.future;
+
+        final TileOverlay tileOverlay1New = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_1'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 1,
+          visible: false,
+          transparency: 0.3,
+          fadeIn: false,
+        );
+
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: GoogleMap(
+              key: key,
+              initialCameraPosition: kInitialCameraPosition,
+              tileOverlays: <TileOverlay>{tileOverlay1New},
+              onMapCreated: (GoogleMapController controller) {
+                fail('update: OnMapCreated should get called only once.');
+              },
+            ),
+          ),
+        );
+
+        await tester.pumpAndSettle(const Duration(seconds: 3));
+
+        final TileOverlay tileOverlayInfo1 = (await inspector
+            .getTileOverlayInfo(tileOverlay1.mapsId, mapId: mapId))!;
+        final TileOverlay? tileOverlayInfo2 = await inspector
+            .getTileOverlayInfo(tileOverlay2.mapsId, mapId: mapId);
+
+        expect(tileOverlayInfo1.visible, isFalse);
+        expect(tileOverlayInfo1.fadeIn, isFalse);
+        expect(tileOverlayInfo1.transparency,
+            moreOrLessEquals(0.3, epsilon: 0.001));
+        expect(tileOverlayInfo1.zIndex, 1);
+
+        expect(tileOverlayInfo2, isNull);
+      },
+    );
+
+    testWidgets(
+      'remove tileOverlays correctly',
+      (WidgetTester tester) async {
+        final Completer<int> mapIdCompleter = Completer<int>();
+        final Key key = GlobalKey();
+        final TileOverlay tileOverlay1 = TileOverlay(
+          tileOverlayId: const TileOverlayId('tile_overlay_1'),
+          tileProvider: _DebugTileProvider(),
+          zIndex: 2,
+          transparency: 0.2,
+        );
+
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: GoogleMap(
+              key: key,
+              initialCameraPosition: kInitialCameraPosition,
+              tileOverlays: <TileOverlay>{tileOverlay1},
+              onMapCreated: (GoogleMapController controller) {
+                mapIdCompleter.complete(controller.mapId);
+              },
+            ),
+          ),
+        );
+
+        final int mapId = await mapIdCompleter.future;
+
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: GoogleMap(
+              key: key,
+              initialCameraPosition: kInitialCameraPosition,
+              onMapCreated: (GoogleMapController controller) {
+                fail('OnMapCreated should get called only once.');
+              },
+            ),
+          ),
+        );
+
+        await tester.pumpAndSettle(const Duration(seconds: 3));
+        final TileOverlay? tileOverlayInfo1 = await inspector
+            .getTileOverlayInfo(tileOverlay1.mapsId, mapId: mapId);
+
+        expect(tileOverlayInfo1, isNull);
+      },
+    );
+  }, skip: isWeb /* Tiles not supported on the web */);
+}
+
+class _DebugTileProvider implements TileProvider {
+  _DebugTileProvider() {
+    boxPaint.isAntiAlias = true;
+    boxPaint.color = Colors.blue;
+    boxPaint.strokeWidth = 2.0;
+    boxPaint.style = PaintingStyle.stroke;
+  }
+
+  static const int width = 100;
+  static const int height = 100;
+  static final Paint boxPaint = Paint();
+  static const TextStyle textStyle = TextStyle(
+    color: Colors.red,
+    fontSize: 20,
+  );
+
+  @override
+  Future<Tile> getTile(int x, int y, int? zoom) async {
+    final ui.PictureRecorder recorder = ui.PictureRecorder();
+    final Canvas canvas = Canvas(recorder);
+    final TextSpan textSpan = TextSpan(
+      text: '$x,$y',
+      style: textStyle,
+    );
+    final TextPainter textPainter = TextPainter(
+      text: textSpan,
+      textDirection: TextDirection.ltr,
+    );
+    textPainter.layout(
+      maxWidth: width.toDouble(),
+    );
+    textPainter.paint(canvas, Offset.zero);
+    canvas.drawRect(
+        Rect.fromLTRB(0, 0, width.toDouble(), width.toDouble()), boxPaint);
+    final ui.Picture picture = recorder.endRecording();
+    final Uint8List byteData = await picture
+        .toImage(width, height)
+        .then((ui.Image image) =>
+            image.toByteData(format: ui.ImageByteFormat.png))
+        .then((ByteData? byteData) => byteData!.buffer.asUint8List());
+    return Tile(width, height, byteData);
+  }
+}
diff --git a/packages/google_maps_flutter/example/lib/custom_marker_icon.dart b/packages/google_maps_flutter/example/lib/custom_marker_icon.dart
new file mode 100644
index 000000000..8940762f0
--- /dev/null
+++ b/packages/google_maps_flutter/example/lib/custom_marker_icon.dart
@@ -0,0 +1,56 @@
+// 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:typed_data';
+import 'dart:ui' as ui;
+
+import 'package:flutter/material.dart';
+
+/// Returns a generated png image in [ByteData] format with the requested size.
+Future<ByteData> createCustomMarkerIconImage({required Size size}) async {
+  final ui.PictureRecorder recorder = ui.PictureRecorder();
+  final Canvas canvas = Canvas(recorder);
+  final _MarkerPainter painter = _MarkerPainter();
+
+  painter.paint(canvas, size);
+
+  final ui.Image image = await recorder
+      .endRecording()
+      .toImage(size.width.floor(), size.height.floor());
+
+  final ByteData? bytes =
+      await image.toByteData(format: ui.ImageByteFormat.png);
+  return bytes!;
+}
+
+class _MarkerPainter extends CustomPainter {
+  @override
+  void paint(Canvas canvas, Size size) {
+    final Rect rect = Offset.zero & size;
+    const RadialGradient gradient = RadialGradient(
+      colors: <Color>[Colors.yellow, Colors.red],
+      stops: <double>[0.4, 1.0],
+    );
+
+    // Draw radial gradient
+    canvas.drawRect(
+      rect,
+      Paint()..shader = gradient.createShader(rect),
+    );
+
+    // Draw diagonal black line
+    canvas.drawLine(
+      Offset.zero,
+      Offset(size.width, size.height),
+      Paint()
+        ..color = Colors.black
+        ..strokeWidth = 1,
+    );
+  }
+
+  @override
+  bool shouldRepaint(_MarkerPainter oldDelegate) => false;
+  @override
+  bool shouldRebuildSemantics(_MarkerPainter oldDelegate) => false;
+}
diff --git a/packages/google_maps_flutter/example/lib/main.dart b/packages/google_maps_flutter/example/lib/main.dart
index 3b1e6361b..a690f21b7 100644
--- a/packages/google_maps_flutter/example/lib/main.dart
+++ b/packages/google_maps_flutter/example/lib/main.dart
@@ -8,6 +8,7 @@ import 'animate_camera.dart';
 import 'lite_mode.dart';
 import 'map_click.dart';
 import 'map_coordinates.dart';
+import 'map_map_id.dart';
 import 'map_ui.dart';
 import 'marker_icons.dart';
 import 'move_camera.dart';
@@ -37,6 +38,7 @@ final List<GoogleMapExampleAppPage> _allPages = <GoogleMapExampleAppPage>[
   const SnapshotPage(),
   const LiteModePage(),
   const TileOverlayPage(),
+  const MapIdPage(),
 ];
 
 /// MapsDemo is the Main Application.
diff --git a/packages/google_maps_flutter/example/lib/map_map_id.dart b/packages/google_maps_flutter/example/lib/map_map_id.dart
new file mode 100644
index 000000000..f15c8c793
--- /dev/null
+++ b/packages/google_maps_flutter/example/lib/map_map_id.dart
@@ -0,0 +1,108 @@
+// 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.
+
+// ignore_for_file: public_member_api_docs
+
+import 'package:flutter/material.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+import 'page.dart';
+
+class MapIdPage extends GoogleMapExampleAppPage {
+  const MapIdPage({Key? key})
+      : super(const Icon(Icons.map), 'Cloud-based maps styling', key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return const MapIdBody();
+  }
+}
+
+class MapIdBody extends StatefulWidget {
+  const MapIdBody({super.key});
+
+  @override
+  State<StatefulWidget> createState() => MapIdBodyState();
+}
+
+const LatLng _kMapCenter = LatLng(52.4478, -3.5402);
+
+class MapIdBodyState extends State<MapIdBody> {
+  GoogleMapController? controller;
+
+  Key _key = const Key('mapId#');
+  String? _mapId;
+  final TextEditingController _mapIdController = TextEditingController();
+
+  @override
+  void initState() {
+    super.initState();
+  }
+
+  void _setMapId() {
+    setState(() {
+      _mapId = _mapIdController.text;
+
+      // Change key to initialize new map instance for new mapId.
+      _key = Key(_mapId ?? 'mapId#');
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final GoogleMap googleMap = GoogleMap(
+        onMapCreated: _onMapCreated,
+        initialCameraPosition: const CameraPosition(
+          target: _kMapCenter,
+          zoom: 7.0,
+        ),
+        key: _key,
+        cloudMapId: _mapId);
+
+    final List<Widget> columnChildren = <Widget>[
+      Padding(
+        padding: const EdgeInsets.all(10.0),
+        child: Center(
+          child: SizedBox(
+            width: 300.0,
+            height: 200.0,
+            child: googleMap,
+          ),
+        ),
+      ),
+      Padding(
+          padding: const EdgeInsets.all(10.0),
+          child: TextField(
+            controller: _mapIdController,
+            decoration: const InputDecoration(
+              hintText: 'Map Id',
+            ),
+          )),
+      Padding(
+          padding: const EdgeInsets.all(10.0),
+          child: ElevatedButton(
+            onPressed: () => _setMapId(),
+            child: const Text(
+              'Press to use specified map Id',
+            ),
+          )),
+    ];
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.stretch,
+      children: columnChildren,
+    );
+  }
+
+  @override
+  void dispose() {
+    _mapIdController.dispose();
+    super.dispose();
+  }
+
+  void _onMapCreated(GoogleMapController controllerParam) {
+    setState(() {
+      controller = controllerParam;
+    });
+  }
+}
diff --git a/packages/google_maps_flutter/example/lib/map_ui.dart b/packages/google_maps_flutter/example/lib/map_ui.dart
index 5348c1001..26c0b2ab7 100644
--- a/packages/google_maps_flutter/example/lib/map_ui.dart
+++ b/packages/google_maps_flutter/example/lib/map_ui.dart
@@ -4,6 +4,7 @@
 
 // ignore_for_file: public_member_api_docs
 
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart' show rootBundle;
 import 'package:google_maps_flutter/google_maps_flutter.dart';
@@ -59,6 +60,7 @@ class MapUiBodyState extends State<MapUiBody> {
   bool _myLocationButtonEnabled = true;
   late GoogleMapController _controller;
   bool _nightMode = false;
+  String _mapStyle = '';
 
   @override
   void initState() {
@@ -243,27 +245,18 @@ class MapUiBodyState extends State<MapUiBody> {
     return rootBundle.loadString(path);
   }
 
-  void _setMapStyle(String mapStyle) {
-    setState(() {
-      _nightMode = true;
-      _controller.setMapStyle(mapStyle);
-    });
-  }
-
   // Should only be called if _isMapCreated is true.
   Widget _nightModeToggler() {
     assert(_isMapCreated);
     return TextButton(
       child: Text('${_nightMode ? 'disable' : 'enable'} night mode'),
-      onPressed: () {
-        if (_nightMode) {
-          setState(() {
-            _nightMode = false;
-            _controller.setMapStyle(null);
-          });
-        } else {
-          _getFileData('assets/night_mode.json').then(_setMapStyle);
-        }
+      onPressed: () async {
+        _nightMode = !_nightMode;
+        final String style =
+            _nightMode ? await _getFileData('assets/night_mode.json') : '';
+        setState(() {
+          _mapStyle = style;
+        });
       },
     );
   }
@@ -278,6 +271,7 @@ class MapUiBodyState extends State<MapUiBody> {
       cameraTargetBounds: _cameraTargetBounds,
       minMaxZoomPreference: _minMaxZoomPreference,
       mapType: _mapType,
+      style: _mapStyle,
       rotateGesturesEnabled: _rotateGesturesEnabled,
       scrollGesturesEnabled: _scrollGesturesEnabled,
       tiltGesturesEnabled: _tiltGesturesEnabled,
@@ -352,5 +346,13 @@ class MapUiBodyState extends State<MapUiBody> {
       _controller = controller;
       _isMapCreated = true;
     });
+    // Log any style errors to the console for debugging.
+    if (kDebugMode) {
+      _controller.getStyleError().then((String? error) {
+        if (error != null) {
+          debugPrint(error);
+        }
+      });
+    }
   }
 }
diff --git a/packages/google_maps_flutter/example/lib/marker_icons.dart b/packages/google_maps_flutter/example/lib/marker_icons.dart
index 847e5ae36..166bba62d 100644
--- a/packages/google_maps_flutter/example/lib/marker_icons.dart
+++ b/packages/google_maps_flutter/example/lib/marker_icons.dart
@@ -5,9 +5,13 @@
 // ignore_for_file: public_member_api_docs
 // ignore_for_file: unawaited_futures
 
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:google_maps_flutter/google_maps_flutter.dart';
 
+import 'custom_marker_icon.dart';
 import 'page.dart';
 
 class MarkerIconsPage extends GoogleMapExampleAppPage {
@@ -29,66 +33,302 @@ class MarkerIconsBody extends StatefulWidget {
 
 const LatLng _kMapCenter = LatLng(52.4478, -3.5402);
 
+enum _MarkerSizeOption {
+  original,
+  width30,
+  height40,
+  size30x60,
+  size120x60,
+}
+
 class MarkerIconsBodyState extends State<MarkerIconsBody> {
+  final Size _markerAssetImageSize = const Size(48, 48);
+  _MarkerSizeOption _currentSizeOption = _MarkerSizeOption.original;
+  Set<Marker> _markers = <Marker>{};
+  bool _scalingEnabled = true;
+  bool _mipMapsEnabled = true;
   GoogleMapController? controller;
-  BitmapDescriptor? _markerIcon;
+  AssetMapBitmap? _markerIconAsset;
+  BytesMapBitmap? _markerIconBytes;
+  final int _markersAmountPerType = 15;
+  bool get _customSizeEnabled =>
+      _currentSizeOption != _MarkerSizeOption.original;
 
   @override
   Widget build(BuildContext context) {
-    _createMarkerImageFromAsset(context);
+    _createCustomMarkerIconImages(context);
+    final Size referenceSize = _getMarkerReferenceSize();
     return Column(
       mainAxisAlignment: MainAxisAlignment.spaceEvenly,
       crossAxisAlignment: CrossAxisAlignment.stretch,
       children: <Widget>[
-        Center(
-          child: SizedBox(
-            width: 350.0,
-            height: 300.0,
-            child: GoogleMap(
-              initialCameraPosition: const CameraPosition(
-                target: _kMapCenter,
-                zoom: 7.0,
+        Column(children: <Widget>[
+          Center(
+            child: SizedBox(
+              width: 350.0,
+              height: 300.0,
+              child: GoogleMap(
+                initialCameraPosition: const CameraPosition(
+                  target: _kMapCenter,
+                  zoom: 7.0,
+                ),
+                markers: _markers,
+                onMapCreated: _onMapCreated,
               ),
-              markers: <Marker>{_createMarker()},
-              onMapCreated: _onMapCreated,
             ),
           ),
-        )
+          TextButton(
+            onPressed: () => _toggleScaling(context),
+            child: Text(_scalingEnabled
+                ? 'Disable auto scaling'
+                : 'Enable auto scaling'),
+          ),
+          if (_scalingEnabled) ...<Widget>[
+            Container(
+              width: referenceSize.width,
+              height: referenceSize.height,
+              decoration: BoxDecoration(
+                border: Border.all(),
+              ),
+            ),
+            Text(
+                'Reference box with size of ${referenceSize.width} x ${referenceSize.height} in logical pixels.'),
+            const SizedBox(height: 10),
+            Image.asset(
+              'assets/red_square.png',
+              scale: _mipMapsEnabled ? null : 1.0,
+            ),
+            const Text('Asset image rendered with flutter'),
+            const SizedBox(height: 10),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.center,
+              children: <Widget>[
+                const Text('Marker size:'),
+                const SizedBox(width: 10),
+                DropdownButton<_MarkerSizeOption>(
+                  value: _currentSizeOption,
+                  onChanged: (_MarkerSizeOption? newValue) {
+                    if (newValue != null) {
+                      setState(() {
+                        _currentSizeOption = newValue;
+                        _updateMarkerImages(context);
+                      });
+                    }
+                  },
+                  items:
+                      _MarkerSizeOption.values.map((_MarkerSizeOption option) {
+                    return DropdownMenuItem<_MarkerSizeOption>(
+                      value: option,
+                      child: Text(_getMarkerSizeOptionName(option)),
+                    );
+                  }).toList(),
+                )
+              ],
+            ),
+          ],
+          TextButton(
+            onPressed: () => _toggleMipMaps(context),
+            child: Text(_mipMapsEnabled ? 'Disable mipmaps' : 'Enable mipmaps'),
+          ),
+        ])
       ],
     );
   }
 
-  Marker _createMarker() {
-    if (_markerIcon != null) {
-      return Marker(
-        markerId: const MarkerId('marker_1'),
-        position: _kMapCenter,
-        icon: _markerIcon!,
-      );
+  String _getMarkerSizeOptionName(_MarkerSizeOption option) {
+    switch (option) {
+      case _MarkerSizeOption.original:
+        return 'Original';
+      case _MarkerSizeOption.width30:
+        return 'Width 30';
+      case _MarkerSizeOption.height40:
+        return 'Height 40';
+      case _MarkerSizeOption.size30x60:
+        return '30x60';
+      case _MarkerSizeOption.size120x60:
+        return '120x60';
+    }
+  }
+
+  (double? width, double? height) _getCurrentMarkerSize() {
+    if (_scalingEnabled) {
+      switch (_currentSizeOption) {
+        case _MarkerSizeOption.width30:
+          return (30, null);
+        case _MarkerSizeOption.height40:
+          return (null, 40);
+        case _MarkerSizeOption.size30x60:
+          return (30, 60);
+        case _MarkerSizeOption.size120x60:
+          return (120, 60);
+        case _MarkerSizeOption.original:
+          return (_markerAssetImageSize.width, _markerAssetImageSize.height);
+      }
     } else {
-      return const Marker(
-        markerId: MarkerId('marker_1'),
-        position: _kMapCenter,
-      );
+      return (_markerAssetImageSize.width, _markerAssetImageSize.height);
     }
   }
 
-  Future<void> _createMarkerImageFromAsset(BuildContext context) async {
-    if (_markerIcon == null) {
-      final ImageConfiguration imageConfiguration =
-          createLocalImageConfiguration(context, size: const Size.square(48));
-      BitmapDescriptor.fromAssetImage(
-              imageConfiguration, 'assets/red_square.png')
-          .then(_updateBitmap);
+  // Helper method to calculate reference size for custom marker size.
+  Size _getMarkerReferenceSize() {
+    final (double? width, double? height) = _getCurrentMarkerSize();
+
+    // Calculates reference size using _markerAssetImageSize aspect ration:
+
+    if (width != null && height != null) {
+      return Size(width, height);
+    } else if (width != null) {
+      return Size(width,
+          width * _markerAssetImageSize.height / _markerAssetImageSize.width);
+    } else if (height != null) {
+      return Size(
+          height * _markerAssetImageSize.width / _markerAssetImageSize.height,
+          height);
+    } else {
+      return _markerAssetImageSize;
     }
   }
 
-  void _updateBitmap(BitmapDescriptor bitmap) {
+  void _toggleMipMaps(BuildContext context) {
+    _mipMapsEnabled = !_mipMapsEnabled;
+    _updateMarkerImages(context);
+  }
+
+  void _toggleScaling(BuildContext context) {
+    _scalingEnabled = !_scalingEnabled;
+    _updateMarkerImages(context);
+  }
+
+  void _updateMarkerImages(BuildContext context) {
+    _updateMarkerAssetImage(context);
+    _updateMarkerBytesImage(context);
+    _updateMarkers();
+  }
+
+  Marker _createAssetMarker(int index) {
+    final LatLng position =
+        LatLng(_kMapCenter.latitude - (index * 0.5), _kMapCenter.longitude - 1);
+    return Marker(
+      markerId: MarkerId('marker_asset_$index'),
+      position: position,
+      icon: _markerIconAsset!,
+    );
+  }
+
+  Marker _createBytesMarker(int index) {
+    final LatLng position =
+        LatLng(_kMapCenter.latitude - (index * 0.5), _kMapCenter.longitude + 1);
+
+    return Marker(
+      markerId: MarkerId('marker_bytes_$index'),
+      position: position,
+      icon: _markerIconBytes!,
+    );
+  }
+
+  void _updateMarkers() {
+    final Set<Marker> markers = <Marker>{};
+    for (int i = 0; i < _markersAmountPerType; i++) {
+      if (_markerIconAsset != null) {
+        markers.add(_createAssetMarker(i));
+      }
+      if (_markerIconBytes != null) {
+        markers.add(_createBytesMarker(i));
+      }
+    }
     setState(() {
-      _markerIcon = bitmap;
+      _markers = markers;
     });
   }
 
+  Future<void> _updateMarkerAssetImage(BuildContext context) async {
+    // Width and height are used only for custom size.
+    final (double? width, double? height) =
+        _scalingEnabled && _customSizeEnabled
+            ? _getCurrentMarkerSize()
+            : (null, null);
+
+    AssetMapBitmap assetMapBitmap;
+    if (_mipMapsEnabled) {
+      final ImageConfiguration imageConfiguration =
+          createLocalImageConfiguration(
+        context,
+      );
+
+      assetMapBitmap = await AssetMapBitmap.create(
+        imageConfiguration,
+        'assets/red_square.png',
+        width: width,
+        height: height,
+        bitmapScaling:
+            _scalingEnabled ? MapBitmapScaling.auto : MapBitmapScaling.none,
+      );
+    } else {
+      // Uses hardcoded asset path
+      // This bypasses the asset resolving logic and allows to load the asset
+      // with precise path.
+      assetMapBitmap = AssetMapBitmap(
+        'assets/red_square.png',
+        width: width,
+        height: height,
+        bitmapScaling:
+            _scalingEnabled ? MapBitmapScaling.auto : MapBitmapScaling.none,
+      );
+    }
+
+    _updateAssetBitmap(assetMapBitmap);
+  }
+
+  Future<void> _updateMarkerBytesImage(BuildContext context) async {
+    final double? devicePixelRatio =
+        MediaQuery.maybeDevicePixelRatioOf(context);
+
+    final Size bitmapLogicalSize = _getMarkerReferenceSize();
+    final double? imagePixelRatio = _scalingEnabled ? devicePixelRatio : null;
+
+    // Create canvasSize with physical marker size
+    final Size canvasSize = Size(
+        bitmapLogicalSize.width * (imagePixelRatio ?? 1.0),
+        bitmapLogicalSize.height * (imagePixelRatio ?? 1.0));
+
+    final ByteData bytes = await createCustomMarkerIconImage(size: canvasSize);
+
+    // Width and height are used only for custom size.
+    final (double? width, double? height) =
+        _scalingEnabled && _customSizeEnabled
+            ? _getCurrentMarkerSize()
+            : (null, null);
+
+    final BytesMapBitmap bitmap = BytesMapBitmap(bytes.buffer.asUint8List(),
+        imagePixelRatio: imagePixelRatio,
+        width: width,
+        height: height,
+        bitmapScaling:
+            _scalingEnabled ? MapBitmapScaling.auto : MapBitmapScaling.none);
+
+    _updateBytesBitmap(bitmap);
+  }
+
+  void _updateAssetBitmap(AssetMapBitmap bitmap) {
+    _markerIconAsset = bitmap;
+    _updateMarkers();
+  }
+
+  void _updateBytesBitmap(BytesMapBitmap bitmap) {
+    _markerIconBytes = bitmap;
+    _updateMarkers();
+  }
+
+  void _createCustomMarkerIconImages(BuildContext context) {
+    if (_markerIconAsset == null) {
+      _updateMarkerAssetImage(context);
+    }
+
+    if (_markerIconBytes == null) {
+      _updateMarkerBytesImage(context);
+    }
+  }
+
   void _onMapCreated(GoogleMapController controllerParam) {
     setState(() {
       controller = controllerParam;
diff --git a/packages/google_maps_flutter/example/lib/place_marker.dart b/packages/google_maps_flutter/example/lib/place_marker.dart
index dc3a08705..1534f3b64 100644
--- a/packages/google_maps_flutter/example/lib/place_marker.dart
+++ b/packages/google_maps_flutter/example/lib/place_marker.dart
@@ -7,11 +7,11 @@
 import 'dart:async';
 import 'dart:math';
 import 'dart:typed_data';
-import 'dart:ui';
 
 import 'package:flutter/material.dart';
 import 'package:google_maps_flutter/google_maps_flutter.dart';
 
+import 'custom_marker_icon.dart';
 import 'page.dart';
 
 class PlaceMarkerPage extends GoogleMapExampleAppPage {
@@ -266,26 +266,10 @@ class PlaceMarkerBodyState extends State<PlaceMarkerBody> {
     });
   }
 
-  Future<BitmapDescriptor> _getAssetIcon(BuildContext context) async {
-    final Completer<BitmapDescriptor> bitmapIcon =
-        Completer<BitmapDescriptor>();
-    final ImageConfiguration config = createLocalImageConfiguration(context);
-
-    const AssetImage('assets/red_square.png')
-        .resolve(config)
-        .addListener(ImageStreamListener((ImageInfo image, bool sync) async {
-      final ByteData? bytes =
-          await image.image.toByteData(format: ImageByteFormat.png);
-      if (bytes == null) {
-        bitmapIcon.completeError(Exception('Unable to encode icon'));
-        return;
-      }
-      final BitmapDescriptor bitmap =
-          BitmapDescriptor.fromBytes(bytes.buffer.asUint8List());
-      bitmapIcon.complete(bitmap);
-    }));
-
-    return bitmapIcon.future;
+  Future<BitmapDescriptor> _getMarkerIcon(BuildContext context) async {
+    const Size canvasSize = Size(48, 48);
+    final ByteData bytes = await createCustomMarkerIconImage(size: canvasSize);
+    return BytesMapBitmap(bytes.buffer.asUint8List());
   }
 
   @override
@@ -382,7 +366,7 @@ class PlaceMarkerBodyState extends State<PlaceMarkerBody> {
                 onPressed: selectedId == null
                     ? null
                     : () {
-                        _getAssetIcon(context).then(
+                        _getMarkerIcon(context).then(
                           (BitmapDescriptor icon) {
                             _setMarkerIcon(selectedId, icon);
                           },
diff --git a/packages/google_maps_flutter/example/lib/place_polyline.dart b/packages/google_maps_flutter/example/lib/place_polyline.dart
index e7997fa44..7cb07ae37 100644
--- a/packages/google_maps_flutter/example/lib/place_polyline.dart
+++ b/packages/google_maps_flutter/example/lib/place_polyline.dart
@@ -291,10 +291,10 @@ class PlacePolylineBodyState extends State<PlacePolylineBody> {
                           child: const Text('change joint type [Android only]'),
                         ),
                         TextButton(
-                          onPressed: isIOS || (selectedId == null)
+                          onPressed: (selectedId == null)
                               ? null
                               : () => _changePattern(selectedId),
-                          child: const Text('change pattern [Android only]'),
+                          child: const Text('change pattern'),
                         ),
                       ],
                     )
diff --git a/packages/google_maps_flutter/example/lib/readme_sample.dart b/packages/google_maps_flutter/example/lib/readme_sample.dart
new file mode 100644
index 000000000..672a37187
--- /dev/null
+++ b/packages/google_maps_flutter/example/lib/readme_sample.dart
@@ -0,0 +1,72 @@
+// 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.
+
+// ignore_for_file: public_member_api_docs
+
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+
+void main() => runApp(const MyApp());
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return const MaterialApp(
+      title: 'Flutter Google Maps Demo',
+      home: MapSample(),
+    );
+  }
+}
+
+// #docregion MapSample
+class MapSample extends StatefulWidget {
+  const MapSample({super.key});
+
+  @override
+  State<MapSample> createState() => MapSampleState();
+}
+
+class MapSampleState extends State<MapSample> {
+  final Completer<GoogleMapController> _controller =
+      Completer<GoogleMapController>();
+
+  static const CameraPosition _kGooglePlex = CameraPosition(
+    target: LatLng(37.42796133580664, -122.085749655962),
+    zoom: 14.4746,
+  );
+
+  static const CameraPosition _kLake = CameraPosition(
+      bearing: 192.8334901395799,
+      target: LatLng(37.43296265331129, -122.08832357078792),
+      tilt: 59.440717697143555,
+      zoom: 19.151926040649414);
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: GoogleMap(
+        mapType: MapType.hybrid,
+        initialCameraPosition: _kGooglePlex,
+        onMapCreated: (GoogleMapController controller) {
+          _controller.complete(controller);
+        },
+      ),
+      floatingActionButton: FloatingActionButton.extended(
+        onPressed: _goToTheLake,
+        label: const Text('To the lake!'),
+        icon: const Icon(Icons.directions_boat),
+      ),
+    );
+  }
+
+  Future<void> _goToTheLake() async {
+    final GoogleMapController controller = await _controller.future;
+    await controller.animateCamera(CameraUpdate.newCameraPosition(_kLake));
+  }
+}
+// #enddocregion MapSample
diff --git a/packages/google_maps_flutter/example/pubspec.yaml b/packages/google_maps_flutter/example/pubspec.yaml
index c7f0610b9..e2afad99b 100644
--- a/packages/google_maps_flutter/example/pubspec.yaml
+++ b/packages/google_maps_flutter/example/pubspec.yaml
@@ -9,8 +9,8 @@ environment:
 dependencies:
   flutter:
     sdk: flutter
-  google_maps_flutter: ^2.1.7
-  google_maps_flutter_platform_interface: ^2.1.2
+  google_maps_flutter: ^2.7.0
+  google_maps_flutter_platform_interface: ^2.7.0
   google_maps_flutter_tizen:
     path: ../
 
diff --git a/packages/google_maps_flutter/lib/src/convert.dart b/packages/google_maps_flutter/lib/src/convert.dart
index ef2f0c553..a862d2226 100644
--- a/packages/google_maps_flutter/lib/src/convert.dart
+++ b/packages/google_maps_flutter/lib/src/convert.dart
@@ -73,8 +73,9 @@ String _rawOptionsToString(Map<String, dynamic> rawOptions) {
     options += ', zoomControl: ${rawOptions['zoomControlsEnabled']}';
   }
 
-  if (rawOptions['styles'] != null) {
-    options += ', styles: ${rawOptions['styles']}';
+  if (rawOptions['style'] != null &&
+      (rawOptions['style'] as String).isNotEmpty) {
+    options += ', styles: ${rawOptions['style']}';
   } else {
     options += ', styles: null';
   }
@@ -251,23 +252,36 @@ util.GMarkerOptions _markerOptionsFromMarker(
   util.GIcon? icon;
 
   if (iconConfig.isNotEmpty) {
-    if (iconConfig[0] == 'fromAssetImage') {
+    if (iconConfig[0] == 'asset') {
       assert(iconConfig.length >= 2);
-      // iconConfig[2] contains the DPIs of the screen, but that information is
-      // already encoded in the iconConfig[1]
-      icon = util.GIcon()..url = '../${iconConfig[1]}';
-
-      // iconConfig[3] may contain the [width, height] of the image, if passed!
-      if (iconConfig.length >= 4 && iconConfig[3] != null) {
-        final List<Object?> rawIconSize = iconConfig[3]! as List<Object?>;
-        final util.GSize size =
-            util.GSize(rawIconSize[0] as num?, rawIconSize[1] as num?);
-        icon
-          ..size = size
-          ..scaledSize = size;
+      final Map<String, Object?> assetConfig =
+          iconConfig[1]! as Map<String, Object?>;
+      icon = util.GIcon()..url = '../${assetConfig['assetName']}';
+      if (assetConfig['width'] != null || assetConfig['height'] != null) {
+        icon.size = util.GSize(
+            assetConfig['width'] != null
+                ? double.parse(assetConfig['width']!.toString())
+                : null,
+            assetConfig['height'] != null
+                ? double.parse(assetConfig['height']!.toString())
+                : null);
+      }
+    } else if (iconConfig[0] == 'bytes') {
+      assert(iconConfig.length >= 2);
+      final Map<String, Object?> assetConfig =
+          iconConfig[1]! as Map<String, Object?>;
+      icon = util.GIcon()
+        ..url =
+            'data:image/png;base64,${base64Encode(assetConfig['byteData']! as List<int>)}';
+      if (assetConfig['width'] != null || assetConfig['height'] != null) {
+        icon.size = util.GSize(
+            assetConfig['width'] != null
+                ? double.parse(assetConfig['width']!.toString())
+                : null,
+            assetConfig['height'] != null
+                ? double.parse(assetConfig['height']!.toString())
+                : null);
       }
-    } else if (iconConfig[0] == 'fromBytes') {
-      throw UnimplementedError('Not Implemented');
     }
   }
 
diff --git a/packages/google_maps_flutter/lib/src/google_maps_controller.dart b/packages/google_maps_flutter/lib/src/google_maps_controller.dart
index c7f064c69..0a78887d4 100644
--- a/packages/google_maps_flutter/lib/src/google_maps_controller.dart
+++ b/packages/google_maps_flutter/lib/src/google_maps_controller.dart
@@ -488,9 +488,10 @@ class GoogleMapsController {
         'JSON.stringify(map.$method.apply(map, $args))');
   }
 
-  Future<num> _getZoom(WebViewController controller) async {
+  Future<double> _getZoom(WebViewController controller) async {
     try {
-      return await _callMethod(controller, 'getZoom', <String>[]) as num;
+      return (await _callMethod(controller, 'getZoom', <String>[]) as num) +
+          0.0;
     } catch (e) {
       debugPrint('JavaScript Error: $e');
       return 0.0;
@@ -592,7 +593,7 @@ class GoogleMapsController {
       JSON.stringify(getPixelToLatLng());
     ''';
 
-    return controller.runJavaScriptReturningResult(command) as String;
+    return await controller.runJavaScriptReturningResult(command) as String;
   }
 
   Future<String> _latLngToPoint(LatLng latLng) async {
@@ -612,11 +613,11 @@ class GoogleMapsController {
       JSON.stringify(getLatLngToPixel());
     ''';
 
-    return controller.runJavaScriptReturningResult(command) as String;
+    return await controller.runJavaScriptReturningResult(command) as String;
   }
 
   /// Returns the zoom level of the current viewport.
-  Future<num> getZoomLevel() async {
+  Future<double> getZoomLevel() async {
     return _getZoom(controller);
   }
 
diff --git a/packages/google_maps_flutter/lib/src/google_maps_flutter_tizen.dart b/packages/google_maps_flutter/lib/src/google_maps_flutter_tizen.dart
index 406aee8a1..71829f643 100644
--- a/packages/google_maps_flutter/lib/src/google_maps_flutter_tizen.dart
+++ b/packages/google_maps_flutter/lib/src/google_maps_flutter_tizen.dart
@@ -213,7 +213,7 @@ class GoogleMapsPlugin extends GoogleMapsFlutterPlatform {
   Future<double> getZoomLevel({
     required int mapId,
   }) {
-    return _map(mapId).getZoomLevel() as Future<double>;
+    return _map(mapId).getZoomLevel();
   }
 
   // The following are the 11 possible streams of data from the native side
diff --git a/packages/google_maps_flutter/pubspec.yaml b/packages/google_maps_flutter/pubspec.yaml
index fa70bac16..e6b49e21e 100644
--- a/packages/google_maps_flutter/pubspec.yaml
+++ b/packages/google_maps_flutter/pubspec.yaml
@@ -2,7 +2,7 @@ name: google_maps_flutter_tizen
 description: Tizen implementation of the google_maps_flutter plugin.
 homepage: https://github.com/flutter-tizen/plugins
 repository: https://github.com/flutter-tizen/plugins/tree/master/packages/google_maps_flutter
-version: 0.1.6
+version: 0.1.7
 
 environment:
   sdk: ">=3.1.0 <4.0.0"
@@ -17,7 +17,7 @@ flutter:
 dependencies:
   flutter:
     sdk: flutter
-  google_maps_flutter_platform_interface: ^2.1.2
+  google_maps_flutter_platform_interface: ^2.7.0
   stream_transform: ^2.0.0
   webview_flutter: ^4.4.2
-  webview_flutter_lwe: ^0.3.1
+  webview_flutter_lwe: ^0.3.2