Weird disappearing error

Question

I have a very weird error where everything disappears after a while

and I think the fault is here

vm

namespace METROWIND.ViewModel
{
    public partial class NewsPageViewModel: ObservableObject
    {
        public ObservableCollection ArticleList { get; set; } = [];

        readonly IHttpService _httpService;
        readonly IDeviceLanguageService _deviceLanguageService;
        readonly IAppService _appService;

        public NewsPageViewModel(IDeviceLanguageService deviceLanguageService,
            IHttpService httpService,
            IAppService appService)
        {
            _deviceLanguageService = deviceLanguageService;
            _httpService = httpService;
            _appService = appService;
            LoadNews();

        }

        public async void LoadNews()
        {
            var language = _deviceLanguageService.GetDeviceCultureInfo();
            var newsUrl = AppConstants.GetNewsUrl(language.TwoLetterISOLanguageName);

            var newsObj = await _httpService.GetAsync(newsUrl);

            if (newsObj != null && newsObj.Articles != null)
            {
                foreach (var article in newsObj.Articles)
                {
                    ArticleList.Add(article);
                }
            }
        }

        [RelayCommand]
        async Task ShowNewsDetail(Article article)
        {
            if (article != null)
            {
                await _appService.NavigateToPage($"{nameof(ArticleDetailsPage)}",
                     new Dictionary {{ "articleObj", article }
                });
            }
        }
    }
}

error

https://reccloud.com/u/rpo2p6u

in this video I show the app working on debug on an emulator, but when I use it in my phone for a while, everything disappears, and I don't get any errors

on the emulator also occurs

https://reccloud.com/u/lgh9z56

i do not know if has something do with the binding mismatch error that I get in the station page

vm

public partial class ChargingStationsMapPageViewModel: AppShellViewModel
{
    public SfPopup? MapDialogPopUp;

    public Map? MapView;

    [ObservableProperty]
    bool isExpanded;

    public ChargingStationsMapPageViewModel(
        ITurbineService turbineService, IAppService
        appService, IServiceProvider serviceProvider,
        NoInternetPopUp noInternetPopUp,
        ICommandHandler commandHandler, IConnectivity connectivity)
        : base(turbineService, appService, serviceProvider, commandHandler, connectivity, noInternetPopUp)
    {
        MapDialogButtons();

    }
    public ObservableCollection MapTypeButtons { get; set; } = [];

    private void MapDialogButtons()
    {
        MapTypeButtons.Add(new MapTypeButton
        {
            Caption = AppResource.Default,
            ImageName = MaterialFonts.Map,
            Selected = true,
            MapNumber = 1
        });
        MapTypeButtons.Add(new MapTypeButton
        {
            Caption = AppResource.Satelite,
            MapNumber = 2,
            ImageName = MaterialFonts.Satellite,
        });
    }

    [RelayCommand]
    void ItemSelected(Turbine Turbine)
    {
        if (Turbine == null || MapView == null)
        {
            return;
        }
        var mapSpan = MapSpan.FromCenterAndRadius(Turbine.Location,
            Distance.FromKilometers(2));

        MapView!.MoveToRegion(mapSpan);
    }

    [RelayCommand]

    void OpenMapLayerOptions()
    {
        MapDialogPopUp!.IsOpen = true;
    }

    [RelayCommand]
    void ChangeMapType(MapTypeButton mapTypeCustomButton)
    {
        if (mapTypeCustomButton == null)
        {
            return;
        }

        foreach (var mapTypeButton in MapTypeButtons)
        {
            mapTypeButton.Selected = false;
        }

        mapTypeCustomButton.Selected = true;

        switch (mapTypeCustomButton.MapNumber)
        {
            case 1:
                MapView!.MapType = MapType.Street;
                break;
            case 2:
                MapView!.MapType = MapType.Satellite;
                break;
        }

        MapDialogPopUp!.IsOpen = false;
    }
}

this view model inherits from the shell

        public AppShellViewModel(ITurbineService turbineService, IAppService appService,
            IServiceProvider serviceProvider, ICommandHandler commandHandler,
            IConnectivity connectivity, NoInternetPopUp noInternetPopUp)
        {
            _serviceProvider = serviceProvider;
            _turbineService = turbineService;
            _appService = appService;
            _commandHandler = commandHandler;
            _connectivity = connectivity;
            _noInternetPopUp = noInternetPopUp;

            _turbineService.NoInternet += TurbineService_NoInternet;

            InitializeCommand();

            _turbineService.SetPinClickHandler(this);

            if (!_isConnectivityEventRegistered)
            {
                _connectivity.ConnectivityChanged += Connectivity_ConnectivityChanged;
                _isConnectivityEventRegistered = true;
            }
        }

        private void TurbineService_NoInternet()
        {
            _noInternetPopUp.Show();
        }

        private void InitializeCommand()
        {
            _commandHandler.SetPinClickedCommand(new Command(async (pin) =>
            await PinMarkerClicked(pin)));
        }

        [RelayCommand]
        async Task Appearing(AppShell appShell)
        {
            _shell = appShell;

            try
            {
                if (TurbinePins.Count == 0 && !isInitializing)
                {
                    isInitializing = true;
                    await _turbineService.InitializeAsync();
                    isInitializing = false;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"Initialization failed: {ex.Message}");
                isInitializing = false;
            }
        }

        private void Connectivity_ConnectivityChanged(object? sender, ConnectivityChangedEventArgs e)
        {
            HandleConnectivityChangeAsync();
        }

        private async void HandleConnectivityChangeAsync()
        {
            if (_connectivity.NetworkAccess == NetworkAccess.Internet)
            {
                _noInternetPopUp.IsOpen = false;

                try
                {
                    if (TurbinePins.Count == 0 && !isInitializing)
                    {
                        isInitializing = true;
                        await _turbineService.InitializeAsync();
                        isInitializing = false;
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"Initialization failed: {ex.Message}");
                    isInitializing = false;
                }
            }
            else
            {
                TurbineService_NoInternet();
            }
        }

        [RelayCommand]
        void OpenMenu()
        {
            IsMenuPopUpOpen = true;
        }

        [RelayCommand]
        void ToggleSwitch()
        {
            if (IsCompactMode)
            {
                _shell!.FlyoutWidth = 65;
            }
            else
            {
                _shell!.FlyoutWidth = 300;
            }

            IsMenuPopUpOpen = false;
        }

        public async Task PinMarkerClicked(TurbinePin turbine)
        {
            if (turbine != null)
            {
#if ANDROID || IOS
                await _appService.NavigateToPage(nameof(TurbineDetailPage),
            new Dictionary { { "SelectedTurbine", turbine } });
#elif WINDOWS || MACCATALYST
                var viewModel = _serviceProvider.GetRequiredService();

                viewModel.SelectedTurbine = turbine;

                var page = _serviceProvider.GetRequiredService();

                page.BindingContext = viewModel;

                var secondWindow = new Window(page);

                var existingWindow = Application.Current!.Windows.FirstOrDefault(
                    w => w.Page is TurbineDetailPage);

                if (existingWindow != null)
                {
                    Application.Current?.ActivateWindow(existingWindow);
                }
                else
                {
                    Application.Current!.OpenWindow(secondWindow);
                }
#endif
            }
        }

ps: btw why the loading text is on the top, in the xmal you can see that is on the center

Could you please check the code

https://github.com/eduardoagr/METROWIND/tree/MetroWind-1-2

Share via

Weird disappearing error

Your answer