Billing/Billing.Shared/UI/Definition.cs

using System;
using System.Threading.Tasks;
using Billing.Languages;
using Xamarin.Forms;

namespace Billing.UI
{
    public static partial class Definition
    {
        public const string PrimaryColorKey = "PrimaryColor";
        public const string DefaultIcon = "ic_default";
        public const long TransparentColor = 0x00ffffffL;

        public static partial (string main, long build) GetVersion();
        public static partial string GetRegularFontFamily();
        public static partial string GetSemiBoldFontFamily();
        public static partial string GetBoldFontFamily();
        public static partial string GetBrandsFontFamily();
    }

    public static class ExtensionHelper
    {
        public static T Binding<T>(this T obj, BindableProperty property, string path, BindingMode mode = BindingMode.Default, IValueConverter converter = null) where T : BindableObject
        {
            obj.SetBinding(property, path, mode, converter);
            return obj;
        }

        public static T HorizontalOptions<T>(this T view, LayoutOptions options) where T : View
        {
            if (view != null)
            {
                view.HorizontalOptions = options;
            }
            return view;
        }

        public static T VerticalOptions<T>(this T view, LayoutOptions options) where T : View
        {
            if (view != null)
            {
                view.VerticalOptions = options;
            }
            return view;
        }

        public static T Margin<T>(this T view, Thickness margin) where T : View
        {
            view.Margin = margin;
            return view;
        }

        public static T DynamicResource<T>(this T view, BindableProperty property, string key) where T : Element
        {
            view.SetDynamicResource(property, key);
            return view;
        }

        public static T GridColumn<T>(this T view, int column) where T : BindableObject
        {
            Grid.SetColumn(view, column);
            return view;
        }

        public static T GridRow<T>(this T view, int row) where T : BindableObject
        {
            Grid.SetRow(view, row);
            return view;
        }

        public static T GridColumnSpan<T>(this T view, int columnSpan) where T : BindableObject
        {
            Grid.SetColumnSpan(view, columnSpan);
            return view;
        }

        public static T GridRowSpan<T>(this T view, int rowSpan) where T : BindableObject
        {
            Grid.SetRowSpan(view, rowSpan);
            return view;
        }

        public static async Task ShowMessage(this Page page, string message, string title = null)
        {
            await page.DisplayAlert(title ?? page.Title, message, Resource.Ok);
        }

        public static async Task<bool> ShowConfirm(this Page page, string message)
        {
            var yes = Resource.Yes;
            var result = await page.DisplayActionSheet(message, Resource.No, yes);
            return result == yes;
        }

        public static DateTime LastMoment(this DateTime date)
        {
            // add 23:59:59.999...
            return date.AddTicks(863999999999);
        }

        public static bool IsTransparent(this long color)
        {
            return (color & 0xff000000L) == 0x00000000L;
        }

        public static Color ToColor(this long color)
        {
            ulong c = (ulong)color;
            int r = (int)(c & 0xff);
            c >>= 8;
            int g = (int)(c & 0xff);
            c >>= 8;
            int b = (int)(c & 0xff);
            c >>= 8;
            int a = (int)(c & 0xff);
            return Color.FromRgba(r, g, b, a);
        }

        public static long ToLong(this Color color)
        {
            long l =
                (uint)(color.A * 255) << 24 |
                (uint)(color.B * 255) << 16 |
                (uint)(color.G * 255) << 8 |
                (uint)(color.R * 255);
            return l;
        }
    }

    public class Tap : IDisposable
    {
        private readonly static object sync = new();
        private static Tap instance;

        private bool busy = false;

        private Tap() { }

        public static bool IsBusy => instance?.busy ?? false;

        public static Tap Start()
        {
            lock (sync)
            {
                (instance ??= new Tap()).busy = true;
            }
            return instance;
        }

        public void Dispose()
        {
            lock (sync)
            {
                busy = false;
            }
        }
    }
}