_localStorage.GetItemAsync<Session>(SessionKey)

using Microsoft.Extensions.Logging;
using Shared.Services;
using Supabase.Gotrue;
using Supabase.Gotrue.Interfaces;

namespace Shared.Provider
{
    public class CustomSupabaseSessionHandler : IGotrueSessionPersistence<Session>
    {
        private const string SessionKey = "SUPABASE_SESSION";
        private readonly ILogger<CustomSupabaseSessionHandler> _logger;

        public CustomSupabaseSessionHandler(ILogger<CustomSupabaseSessionHandler> logger)
        {
            _logger = logger;
        }

        public void SaveSession(Session session)
        {
            StoreService.Set(SessionKey, session);
        }

        public void DestroySession()
        {
            StoreService.Delete(SessionKey);
        }

        public Session? LoadSession()
        {
            var session = StoreService.Get<Session>(SessionKey);
            return session?.ExpiresAt() <= DateTime.Now ? null : session;
        }
    }
}

using Newtonsoft.Json;
using Xamarin.Essentials;

namespace Shared.Services
{
    public static class StoreService
    {
        public static void Set(string key, object value)
        {
            string keyvalue = JsonConvert.SerializeObject(value);

            if (keyvalue != null && !string.IsNullOrEmpty(keyvalue))
            {
                Preferences.Set(key, keyvalue);
            }
        }

        public static T Get<T>(string key)
        {
            T UnpackedValue = default;
            string keyvalue = Preferences.Get(key, string.Empty);

            if (keyvalue != null && !string.IsNullOrEmpty(keyvalue))
            {
                UnpackedValue = JsonConvert.DeserializeObject<T>(keyvalue);
            }

            return UnpackedValue;
        }

        public static void Delete(string key)
        {
            Preferences.Remove(key);
        }

        public static bool ContainsKey(string key)
        {
            return Preferences.ContainsKey(key);
        }

        public static void ClearAll()
        {
            Preferences.Clear();
        }
    }
}

            // Supabase
            builder.Services.AddScoped<Supabase.Client>(
                provider =>
                {
                    var session = new CustomSupabaseSessionHandler(provider.GetRequiredService<ILogger<CustomSupabaseSessionHandler>>());

                    var client = new Supabase.Client(
                        url,
                        supabaseKey,
                        new Supabase.SupabaseOptions
                        {
                            AutoRefreshToken = true,
                            AutoConnectRealtime = true,
                            SessionHandler = session
                        }
                    );

                    client.Auth.LoadSession();

                    return client;
                }
            );