[google_maps_flutter] Adopts new async/await Swift Pigeon support

[stuartmorgan-g]

Switches from the callback-based Pigeon API to the new async/await-based API, which is:

• more idiomatic modern Swift
• safer, both since it uses Pigeon-generated actor annotations to ensure proper threading, and because it prevents the error case of calling the callback some number of times other than exactly once (which violates the engine API contract)
• the syntax used by the new FFI backend that we plan to switch to in a follow-up

I verified that with this version of Pigeon we are no longer seeing thread violation logging in manual testing (see flutter/flutter#192199)

There is some extra Task boilerplate in many callbacks still because we are implementing APIs that are defined by the Google Maps API, and those are not yet using async and actor annotations, so we have to bridge them in the plugin layer.

Part of flutter/flutter#192720

Pre-Review Checklist

• I read the Contributor Guide and followed the process outlined there for submitting PRs.
• I read the AI contribution guidelines and understand my responsibilities, or I am not using AI tools.
• I read the Tree Hygiene page, which explains my responsibilities.
• I read and followed the relevant style guides and ran the auto-formatter.
• I signed the CLA.
• The title of the PR starts with the name of the package surrounded by square brackets, e.g. [shared_preferences]
• I linked to at least one issue that this PR fixes in the description above.
• I followed the version and CHANGELOG instructions, using semantic versioning and the repository CHANGELOG style, or I have commented below to indicate which documented exception this PR falls under¹.
• I updated/added any relevant documentation (doc comments with ///).
• I added new tests to check the change I am making, or I have commented below to indicate which test exemption this PR falls under¹.
• All existing and new tests are passing.

Footnotes

1. Regular contributors who have demonstrated familiarity with the repository guidelines only need to comment if the PR is not auto-exempted by repo tooling. ↩ ↩²

[gemini-code-assist]

Code Review

This pull request updates the google_maps_flutter iOS packages (sdk9, sdk10, and shared) to adopt the new Pigeon async Swift support, converting callback-based asynchronous methods to Swift's async/throws syntax. Feedback on the changes identifies potential memory retention issues in TileOverlayController.swift across all three packages due to capturing self strongly inside the asynchronous Task closures, and recommends capturing self weakly to prevent delayed deallocation.

[gemini-code-assist]

Capturing self strongly inside the Task closure can lead to memory retention issues. Since tileProviderDelegate.tile is an asynchronous call (await), self (the TileProviderController layer) will be kept in memory for the entire duration of the platform channel call. If the layer is removed or the map is disposed while tile requests are in flight, this can delay deallocation of the layer and associated resources.

To prevent this, capture self weakly and retrieve the necessary properties before the asynchronous call, using optional chaining for the remaining references.

  override func requestTileFor(x: UInt, y: UInt, zoom: UInt, receiver: any GMSTileReceiver) {
    Task { [weak self] @MainActor in
      guard let tileProviderDelegate = self?.tileProviderDelegate,
            let tileOverlayIdentifier = self?.tileOverlayIdentifier else {
        receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: kGMSTileLayerNoTile)
        return
      }
      var tileImage = kGMSTileLayerNoTile
      do {
        let tile = try await tileProviderDelegate.tile(
          withOverlayIdentifier: tileOverlayIdentifier,
          location: PlatformPoint(x: Double(x), y: Double(y)),
          zoom: Int64(zoom)
        )
        if let data = tile.data?.data {
          tileImage = self?.handleResultTile(UIImage(data: data)) ?? kGMSTileLayerNoTile
        }
      } catch {
        let message =
          if let error = error as? PigeonError {
            "Can't get tile: errorCode = \(error.code), errorMessage = \(error.message ?? "nil"), details = \(error.details ?? "nil")"
          } else {
            "Can't get tile: unexpected error \(error)"
          }
        NSLog(message)
      }
      receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: tileImage)
    }
  }

[gemini-code-assist]

Capturing self strongly inside the Task closure can lead to memory retention issues. Since tileProviderDelegate.tile is an asynchronous call (await), self (the TileProviderController layer) will be kept in memory for the entire duration of the platform channel call. If the layer is removed or the map is disposed while tile requests are in flight, this can delay deallocation of the layer and associated resources.

To prevent this, capture self weakly and retrieve the necessary properties before the asynchronous call, using optional chaining for the remaining references.

  override func requestTileFor(x: UInt, y: UInt, zoom: UInt, receiver: any GMSTileReceiver) {
    Task { [weak self] @MainActor in
      guard let tileProviderDelegate = self?.tileProviderDelegate,
            let tileOverlayIdentifier = self?.tileOverlayIdentifier else {
        receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: kGMSTileLayerNoTile)
        return
      }
      var tileImage = kGMSTileLayerNoTile
      do {
        let tile = try await tileProviderDelegate.tile(
          withOverlayIdentifier: tileOverlayIdentifier,
          location: PlatformPoint(x: Double(x), y: Double(y)),
          zoom: Int64(zoom)
        )
        if let data = tile.data?.data {
          tileImage = self?.handleResultTile(UIImage(data: data)) ?? kGMSTileLayerNoTile
        }
      } catch {
        let message =
          if let error = error as? PigeonError {
            "Can't get tile: errorCode = \(error.code), errorMessage = \(error.message ?? "nil"), details = \(error.details ?? "nil")"
          } else {
            "Can't get tile: unexpected error \(error)"
          }
        NSLog(message)
      }
      receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: tileImage)
    }
  }

[gemini-code-assist]

Capturing self strongly inside the Task closure can lead to memory retention issues. Since tileProviderDelegate.tile is an asynchronous call (await), self (the TileProviderController layer) will be kept in memory for the entire duration of the platform channel call. If the layer is removed or the map is disposed while tile requests are in flight, this can delay deallocation of the layer and associated resources.

To prevent this, capture self weakly and retrieve the necessary properties before the asynchronous call, using optional chaining for the remaining references.

  override func requestTileFor(x: UInt, y: UInt, zoom: UInt, receiver: any GMSTileReceiver) {
    Task { [weak self] @MainActor in
      guard let tileProviderDelegate = self?.tileProviderDelegate,
            let tileOverlayIdentifier = self?.tileOverlayIdentifier else {
        receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: kGMSTileLayerNoTile)
        return
      }
      var tileImage = kGMSTileLayerNoTile
      do {
        let tile = try await tileProviderDelegate.tile(
          withOverlayIdentifier: tileOverlayIdentifier,
          location: PlatformPoint(x: Double(x), y: Double(y)),
          zoom: Int64(zoom)
        )
        if let data = tile.data?.data {
          tileImage = self?.handleResultTile(UIImage(data: data)) ?? kGMSTileLayerNoTile
        }
      } catch {
        let message =
          if let error = error as? PigeonError {
            "Can't get tile: errorCode = \(error.code), errorMessage = \(error.message ?? "nil"), details = \(error.details ?? "nil")"
          } else {
            "Can't get tile: unexpected error \(error)"
          }
        NSLog(message)
      }
      receiver.receiveTileWith(x: x, y: y, zoom: zoom, image: tileImage)
    }
  }