Marker Management

import 'package:lazarillo_maps/lazarillo_maps.dart';
 
// Add a basic marker
final basicMarker = LzBasicMarker(
  'pin',
  const LatLng(-33.417733, -70.606573),
);
await lazarilloMapWidget.addMarker(basicMarker);
 
// Add an attribute marker
final attributeMarker = LzAttributeMarker(
  'restaurant',
  const LatLng(-33.418000, -70.607000),
  title: 'Restaurant',
  text: 'RESTAURANT',
  textColor: '#FFFFFF',
  iconColor: '#FF9800',
);
await lazarilloMapWidget.addMarker(attributeMarker);

// Remove a specific marker by its ID (String)
// The marker ID is returned by addMarker()
final markerId = await lazarilloMapWidget.addMarker(basicMarker);
await lazarilloMapWidget.removeMarker(markerId);
 
// Remove all markers
await lazarilloMapWidget.clearMarkers();

import 'package:flutter/material.dart';
import 'package:lazarillo_maps/lazarillo_maps.dart';
 
class MarkerManagementExample extends StatefulWidget {
  @override
  _MarkerManagementExampleState createState() => _MarkerManagementExampleState();
}
 
class _MarkerManagementExampleState extends State<MarkerManagementExample> {
  LazarilloMapWidget? mapWidget;
  LazarilloMaps? lazarilloMaps;
  Map<String, LzMarker> markerMap = {}; // markerId -> marker
 
  @override
  void initState() {
    super.initState();
    _initializeMap();
  }
 
  Future<void> _initializeMap() async {
    lazarilloMaps = LazarilloMaps('your-api-key');
    await lazarilloMaps!.initialize();
 
    final mapConfig = MapConfiguration(
      latitude: -33.417733,
      longitude: -70.606573,
      zoom: 15.0,
    );
 
    mapWidget = lazarilloMaps!.getLazarilloMapWidget(
      mapConfig,
      (String mapId) {
        print('Map ready: $mapId');
        _loadInitialMarkers();
      },
    );
 
    setState(() {});
  }
 
  Future<void> _loadInitialMarkers() async {
    if (mapWidget == null) return;
 
    try {
      final initialMarkers = <LzMarker>[
        LzBasicMarker('pin', const LatLng(-33.417733, -70.606573)),
        LzAttributeMarker(
          'restaurant',
          const LatLng(-33.418000, -70.607000),
          title: 'Restaurant',
          text: 'RESTAURANT',
          textColor: '#FFFFFF',
          iconColor: '#FF9800',
        ),
      ];
 
      for (final marker in initialMarkers) {
        await _addMarker(marker);
      }
 
      print('Initial markers loaded: ${markerMap.length}');
    } catch (e) {
      print('Error loading initial markers: $e');
    }
  }
 
  Future<void> _addMarker(LzMarker marker) async {
    if (mapWidget == null) return;
 
    try {
      final markerId = await mapWidget!.addMarker(marker);
      if (markerId != null) {
        markerMap[markerId] = marker;
        setState(() {});
      }
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error adding marker: $e')),
      );
    }
  }
 
  Future<void> _removeMarker(String markerId) async {
    if (mapWidget == null) return;
 
    try {
      await mapWidget!.removeMarker(markerId);
      markerMap.remove(markerId);
      setState(() {});
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error removing marker: $e')),
      );
    }
  }
 
  Future<void> _clearAllMarkers() async {
    if (mapWidget == null) return;
 
    try {
      await mapWidget!.clearMarkers();
      markerMap.clear();
      setState(() {});
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error clearing markers: $e')),
      );
    }
  }
 
  Future<void> _addRandomMarker() async {
    final random = DateTime.now().millisecondsSinceEpoch;
    final lat = -33.417733 + (random % 1000) / 100000;
    final lng = -70.606573 + (random % 1000) / 100000;
 
    final markerTypes = ['basic', 'attribute'];
    final markerType = markerTypes[random % markerTypes.length];
 
    LzMarker marker;
    switch (markerType) {
      case 'attribute':
        marker = LzAttributeMarker(
          'restaurant',
          LatLng(lat, lng),
          title: 'Marker ${markerMap.length + 1}',
          text: 'POINT ${markerMap.length + 1}',
          textColor: '#FFFFFF',
          iconColor: '#FF5722',
        );
      default:
        marker = LzBasicMarker('pin', LatLng(lat, lng));
    }
 
    await _addMarker(marker);
  }
 
  @override
  Widget build(BuildContext context) {
    if (mapWidget == null) {
      return const Scaffold(
        body: Center(child: CircularProgressIndicator()),
      );
    }
 
    return Scaffold(
      appBar: AppBar(
        title: const Text('Marker Management'),
        actions: [
          IconButton(
            onPressed: _clearAllMarkers,
            icon: const Icon(Icons.clear_all),
            tooltip: 'Clear All',
          ),
        ],
      ),
      body: Column(
        children: [
          Container(
            padding: const EdgeInsets.all(16),
            color: Colors.grey.shade100,
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                Text(
                  'Marker Management',
                  style: Theme.of(context).textTheme.titleMedium,
                ),
                const SizedBox(height: 8),
                Text('Total markers: ${markerMap.length}'),
                const SizedBox(height: 16),
                Row(
                  children: [
                    Expanded(
                      child: ElevatedButton.icon(
                        onPressed: _addRandomMarker,
                        icon: const Icon(Icons.add_location),
                        label: const Text('Add Random'),
                      ),
                    ),
                    const SizedBox(width: 8),
                    Expanded(
                      child: ElevatedButton.icon(
                        onPressed: _clearAllMarkers,
                        icon: const Icon(Icons.clear_all),
                        label: const Text('Clear All'),
                        style: ElevatedButton.styleFrom(
                          backgroundColor: Colors.red,
                          foregroundColor: Colors.white,
                        ),
                      ),
                    ),
                  ],
                ),
              ],
            ),
          ),
          if (markerMap.isNotEmpty)
            SizedBox(
              height: 80,
              child: ListView(
                scrollDirection: Axis.horizontal,
                children: markerMap.entries.map((entry) {
                  return Container(
                    width: 180,
                    margin: const EdgeInsets.all(8),
                    child: Card(
                      child: ListTile(
                        leading: Icon(
                          entry.value is LzBasicMarker
                              ? Icons.location_on
                              : Icons.label,
                        ),
                        title: Text(entry.key.substring(0, 8)),
                        trailing: IconButton(
                          onPressed: () => _removeMarker(entry.key),
                          icon: const Icon(Icons.delete),
                          color: Colors.red,
                        ),
                      ),
                    ),
                  );
                }).toList(),
              ),
            ),
          Expanded(child: mapWidget!),
        ],
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _addRandomMarker,
        tooltip: 'Add Random Marker',
        child: const Icon(Icons.add_location),
      ),
    );
  }
}

class MarkerManager {
  final Map<String, LzMarker> _markers = {};
  final LazarilloMapWidget _mapWidget;
 
  MarkerManager(this._mapWidget);
 
  Future<String?> addMarker(LzMarker marker) async {
    // Limit marker count to avoid performance issues
    if (_markers.length >= 100) {
      await _removeOldestMarker();
    }
 
    final markerId = await _mapWidget.addMarker(marker);
    if (markerId != null) {
      _markers[markerId] = marker;
    }
    return markerId;
  }
 
  Future<void> _removeOldestMarker() async {
    if (_markers.isNotEmpty) {
      final oldestId = _markers.keys.first;
      await _mapWidget.removeMarker(oldestId);
      _markers.remove(oldestId);
    }
  }
 
  Future<void> clearAll() async {
    await _mapWidget.clearMarkers();
    _markers.clear();
  }
}