Plugin Boilerplate ponderings....

[ibrierley]

So whenever I want to write some new code, mainly to mess around with a new plugin or something, I always get a bit confused with the amount of boilerplate I "feel" like I need. Example, here's what I've just written, that does nothing basically so far....

Just wondering, is this what others do, is there a more optimal way (if you just want access to the map object etc) ? Or could there be a better way if things in flutter_map were rejigged ?

class SliceLayerOptions extends LayerOptions {
  final someOption = "Some Option";

  SliceLayerOptions();
}

class SliceLayerWidget extends StatelessWidget {
  final SliceLayerOptions options;

  SliceLayerWidget({Key? key, required this.options}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    final mapState = MapState.maybeOf(context)!;

    return SliceLayer(
      mapState: mapState,
      stream: mapState.onMoved,
      options: options,
    );
  }
}

class SliceLayer extends StatefulWidget {
  final SliceLayerOptions options;
  final MapState mapState;
  final Stream<Null> stream;

  SliceLayer({
    required this.options,
    required this.mapState,
    required this.stream,
  }) : super(key: options.key);

  @override
  State<StatefulWidget> createState() {
    return _SliceLayerState();
  }
}

class _SliceLayerState extends State<SliceLayer> with TickerProviderStateMixin {
  MapState get map => widget.mapState;

  SliceLayerOptions get options => widget.options;
  late Bounds _globalTileRange;

  @override
  Widget build(BuildContext context) {
    print("Map $map");
    return Text("Widget");
  }
}

[ibrierley]

Actually I don't think I need a layer and layeroptions if I just use a widget, children (and ignore the main plugins option) and maybeOf....

class SliceLayerWidget extends StatefulWidget {

  SliceLayerWidget({Key? key, this.index}) : super(key: key);

  @override
  _SliceLayerWidgetState createState() => _SliceLayerWidgetState();
}

class _SliceLayerWidgetState extends State<SliceLayerWidget> {

  @override
  Widget build(BuildContext context) {
    final mapState = MapState.maybeOf(context)!;
  }  
}

and then later in FlutterMap...

children: <Widget>[SliceLayerWidget()],

Just thinking out loud, not quite so familiar with that route, or if there's any drawbacks...(possibly if one needs to use the events stream, I'm not sure there's access to that, without a _createLayer which gets called internally from a plugin layer and options?)