Platform-native implementation selector

One capability. Four runtimes. Six lifecycle states.

Choose the exact mobile path you are shipping. The matrix preserves current version evidence, exposes missing overview coverage, and makes the host application—not the provider UI—the owner of durable state.

Select a path Run the stateful host

Coverage, without parity theatre

Twenty paths. Every gap visible.

“Not listed” means the current overview does not establish a package. It does not mean the capability is impossible, and it never licenses reuse of another platform’s package.

Six-state adapter contract

Make every return, cancellation, and late callback explainable.

The generated scaffold deliberately stops at an application-owned candidate. Your repository decides whether and how that candidate becomes durable.

Application screen

idle

No provider controller, route, Promise, delegate, or listener is active.

Platform adapter

launching

One generation ID binds configuration, owner, and launch time.

Provider widget under host lifecycle

active

Background, recreation, close, and duplicate-launch behavior are observable.

Platform adapter

returned / cancelled / failed

Exactly one typed terminal result wins; late results are ignored.

Application domain

candidate

Validate and normalize application route request/revision identity; provider ui is not a navigation session before committing.

Application repository

committed

Persist the normalized selection/draft with version, actor, source, and audit event.

Flutter host adapter boundary

final class PlaceSelection {
  const PlaceSelection(this.mapplsPin, this.label);
  final String mapplsPin;
  final String label;
}

abstract interface class MapplsPlaceWidget {
  Future<PlaceSelection?> selectPlace();
}

Future<void> choose(MapplsPlaceWidget widget) async {
  final generation = ++_launchGeneration;
  final selected = await widget.selectPlace();
  if (!mounted || generation != _launchGeneration || selected == null) return;
  if (!RegExp(r'^[A-Za-z0-9]{6}$').hasMatch(selected.mapplsPin)) throw const FormatException('invalid_mappls_pin');
  setState(() => _selected = selected); // Persist through the app repository on submit.
}

State ownership

The widget is a collaborator, not your database.

One route/widget state owns the MethodChannel launch Future, mounted check, cancellation, and application commit.

Validate the returned platform value, Mappls Pin, and request generation before updating Dart state.

A null result, PlatformException, route disposal, background interruption, and user cancellation are not interchangeable.

The durable record is application route request/revision identity; provider ui is not a navigation session; never retain a provider view/controller or opaque bridge result.

Production gate

Test the lifecycle you cannot demo.

Happy-path selection proves almost nothing about a production mobile integration.

Android and iOS plugin versions are resolved by one lockfile

Every awaited result checks mounted/generation

PlatformException is mapped to a typed UI state

A late result cannot update a disposed route

Permission/configuration denied

Offline and slow provider response

Cancel before and after a candidate appears

Host edit invalidates a stale selection

Duplicate callback/Promise result commits once

Accessibility, focus return, and a non-widget fallback