5.0 RC - Logger overlay visible by default? .NET MAUI

[jamesmontemagno]

Mapsui Version
5.0-rc1

Mapsui Platform
Tested on .NET MAUI

Device
Android

Describe the bug
overlay text is visible showing navigator otuput:

To Reproduce
Load up map and use navigator to move to location

Expected behavior
Ability to turn off?

[pauldendulk]

Hi James! This is the best feature of V5 😉. Logging in the map is shown when a debugger is attached but not without. So, you don't need to change anything.

If you really need to it is possible to disable it while debugging by setting this static property:

LoggingWidget.ShowLoggingInMap = ActiveMode.No;

This can be useful if you want to make a screenshot or if you want to see how it will look for the end user. But don't forget to turn it on again! Here is some documentation:
https://mapsui.com/v5/logging/#show-logging-in-the-map

An alternative is to start the exe from disk instead of the IDE. If you run the release build from visual studio it will still show the logging, this is because 'having a debugger attached' and 'building a release' are completely independent things. Instead you could start the app directly from the folder, this would remove the logging in the map.

Logging in the map already saved me tons of debug time. Often I see in seconds what is wrong where otherwise I would have to start some debugging session, or worse, would not realize that something was wrong.

If you need any other help upgrading then I could help. I have time this week. You could mail me at pauldendulk@gmail.com.

Here is an incomplete upgrade guide: https://mapsui.com/v5/v5.0-upgrade-guide/

[pauldendulk]

I will add some additional information to the first log line, like 'This will not show in release mode', because you are not the first one to ask.

Also interesting for you, we now have an OutLine for LineStrings, you mentioned this was missing when working with V4.

[AhmadovMahammad]

public class MapService : IMapService
{
    private Map? _currentMap;
    private readonly Dictionary<string, BaseWidget> _defaultWidgets = [];

    public Map CreateMap() => CreateMap(null);
    public Map CreateMap(MapConfiguration? configuration)
    {
        var config = configuration ?? new MapConfiguration();

        _currentMap = new Map
        {
            CRS = config.CRS,
            BackColor = config.BackColor,
            Navigator = { Limiter = new ViewportLimiterKeepWithinExtent() }
        };

        ConfigureDefaults(_currentMap, config);
        return _currentMap;
    }

    public void ConfigureDefaults(Map map, MapConfiguration config)
    {
        LoggingWidget.ShowLoggingInMap = config.EnableLogging ? ActiveMode.Yes : ActiveMode.No;

        if (config.EnablePerformanceWidget)
        {
            if (map.Widgets.FirstOrDefault(w => w is PerformanceWidget) is PerformanceWidget perf)
            {
                perf.HorizontalAlignment = HorizontalAlignment.Right;
                perf.VerticalAlignment = VerticalAlignment.Top;
                perf.Margin = new MRect(10, 10);

                _defaultWidgets["Performance"] = perf;
            }
        }

        if (config.EnableScaleBar)
        {
            var scaleBar = new ScaleBarWidget(map)
            {
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Bottom,
                TextAlignment = Alignment.Left,
                ScaleBarMode = ScaleBarMode.Both,
                SecondaryUnitConverter = ImperialUnitConverter.Instance,
                MaxWidth = 200,
                Margin = new MRect(10, 10)
            };

            _defaultWidgets["ScaleBar"] = scaleBar;
            map.Widgets.Add(scaleBar);
        }
    }

    public IReadOnlyCollection<WidgetInfo> GetWidgets()
    {
        var widgets = _defaultWidgets.Select(kv => new WidgetInfo(kv.Key, kv.Value));
        return widgets.ToList().AsReadOnly();
    }

    public bool ToggleWidget(string id, bool isEnabled)
    {
        if (_defaultWidgets.TryGetValue(id, out BaseWidget? baseWidget) && baseWidget != null)
        {
            baseWidget.Enabled = isEnabled;
            return true;
        }

        return false;
    }
}

public class MapConfiguration
{
    public string CRS { get; set; } = "EPSG:3857";
    public Color BackColor { get; set; } = Color.White;

    public bool EnablePerformanceWidget { get; set; } = true;
    public bool EnableScaleBar { get; set; } = true;
    public bool EnableLogging { get; set; }
}

i handled this situation like this, actually it helps in development mode (showing performance widget i mean)

[pauldendulk]

RC.1 will contain extra loglines to explain how to turn it off.

See: https://github.com/Mapsui/Mapsui/pull/3163/files#diff-7815315e00587da68f8ce147bf4864a2092fd94678186861b4e3787c020fa44dR114-R115

[pauldendulk]

@AhmadovMahammad Thanks! Could you mention some scenarios where this is useful to you? I would like to make this kind of configuration easier but need some better idea of what I should support. I created a MapBuilder which is somewhat related to this, perhaps you could take a look at that. It is not very useful yet, I need to spend more time on it.

What I am also thinking about is to use an IConfiguration. I use this in ASP.NET Web API a lot and also set this up in my MAUI projects. I have certain settings in a appsettings.Development.local.json (git ignored) where I configure things that I need during development. Perhaps the Map should get a IConfiguration in the constructor.

[AhmadovMahammad]

@pauldendulk I looked into the current MapBuilder inside Mapsui. It’s a good starting point for composing maps in code, but it still works at a very procedural level. It just collects delegates like AddLayer, AddWidget, or ConfigureMap, then runs them inside Build().

In my own projects (Avalonia and WPF) I needed something that can build maps based on environment and configuration. For example, in development I enable LoggingWidget and PerformanceWidget, in production I disable them. Sometimes I switch CRS, background color, or base tile source by environment too.

To handle this, I created a small MapService and MapInitializer. They read from a MapConfiguration model (or from a JSON file) and automatically add base layers, widgets, and defaults. Example JSON for base maps:

[
  {
    "Kind": "OpenStreetMap",
    "UrlTemplate": "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
    "Name": "OpenStreetMap",
    "Attribution": "OpenStreetMap contributors"
  },
  {
    "Kind": "CartoDark",
    "UrlTemplate": "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png",
    "Name": "Carto Dark",
    "Attribution": "OpenStreetMap contributors - CARTO",
    "Subdomains": ["a","b","c","d"]
  }
]

and the service builds the map:

var map = _mapService.CreateMap(new MapConfiguration
{
    CRS = "EPSG:3857",
    EnableScaleBar = true,
    EnablePerformanceWidget = isDevelopment,
    EnableLogging = isDevelopment
});

I think this could combine nicely with your idea of giving Map or MapBuilder an IConfiguration.
But if MapBuilder is going to consume configuration directly, then its structure should be consistent across all UI platforms and follow a clean, serializable model.

For example:

{
  "Map": {
    "Crs": "EPSG:3857",
    "BackColor": "#FFFFFF",
    "Widgets": {
      "Performance": true,
      "ScaleBar": true,
      "Logging": false
    },
    "BaseLayer": "OpenStreetMap"
  }
}

Then MapBuilder could read this:

var map = new MapBuilder(configuration.GetSection("Map"))
    .UseConfiguredLayers()
    .UseConfiguredWidgets()
    .Build();

This keeps the declarative part outside the app logic and makes map initialization the same for WPF, Avalonia, MAUI, etc.

In short, my main goal was to remove repeated setup code and make it easy to switch between dev and prod modes through json configuration, not through hardcoded logic.

To give a small idea of how this could look in code, here is a simplified example of what a more structured MapBuilder might do:

// Load configuration from appsettings or json file
var builder = MapBuilder
    .FromConfiguration(configuration.GetSection("Map"))

    // Optional fluent overrides (runtime)
    .WithLayer("DefaultBase", map => 
        new TileLayer(OpenStreetMap.Create()))

    .WithWidget("ScaleBar", (map, widget) => {
        widget.HorizontalAlignment = HorizontalAlignment.Left;
        widget.VerticalAlignment = VerticalAlignment.Bottom;
    })

    // Optional per-environment tweak
    .When(Environment.IsDevelopment(), b => 
        b.WithWidget("PerformanceWidget"))

    // Finally build the map
    .Build();

In this pattern, the configuration defines defaults (CRS, colors, widgets, base layer), and the fluent API allows programmatic overrides or conditional logic.
This keeps the json schema simple but still gives developers control when needed.

[jamesmontemagno]

This is awesome @pauldendulk and makes 100% sense! Very exciting. Thanks for adding the additional info. Super smooth transition from XF version 4 to .NET MAUI v5!

[pauldendulk]

@jamesmontemagno Great to hear! There’s still a lot to improve, but we’re getting there step by step. We’d love to hear your thoughts, what parts feel most frustrating or what’s missing? We will take it into account.

And thanks for sponsoring! 💖🙏

[pauldendulk]

@AhmadovMahammad Thanks for looking into this. I created a new issue with your comment. I have no time to look into this right now because of things related to the release. Also it does not have a lot of priority for the coming months, but perhaps I can give a little attention #3192