I need to change the ChoreographerTimer class

[moliveto]

I need to change this class: https://github.com/AvaloniaUI/Avalonia/blob/master/src/Android/Avalonia.Android/ChoreographerTimer.cs Because i need to implement my own FPS (Frame per seconds) But i have problems with the interface IRenderTimer because is marked as [PrivateApi]

Bellow there are my implementation of this class but i can't compile because the error previously explained

using System.Reactive.Disposables;
using Android.OS;
using Android.Views;
using Avalonia.Android;
using Avalonia.Rendering;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Java.Lang;
using Thread = System.Threading.Thread;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Avalonia")]
[assembly: InternalsVisibleTo("Avalonia.Android")]
[assembly: InternalsVisibleTo("Avalonia.Base")]
[assembly: InternalsVisibleTo("Avalonia.Rendering")]
[assembly: InternalsVisibleTo("Avalonia.Metadata")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

namespace RunApp.Avalonia.Android;

internal class ChoreographerTimer : Java.Lang.Object, IRenderTimer, Choreographer.IFrameCallback
{
    private readonly object _lock = new();
    private readonly Thread _thread;
    private readonly TaskCompletionSource<Choreographer> _choreographer = new();
    private readonly HashSet<AvaloniaView> _views = new();
    private Action<TimeSpan>? _tick;
    private int _count;
    private readonly long _frameIntervalNanos;
    private bool _isPaused;
    private long _lastFrameTimeNanos;

    public ChoreographerTimer(int framesPerSecond = 60)
    {
        _frameIntervalNanos = 1_000_000_000 / framesPerSecond;
        _thread = new Thread(Loop) { IsBackground = true };
        _thread.Start();
    }

    internal bool RunsInBackground { get; } = true;

    internal event Action<TimeSpan> Tick
    {
        add
        {
            lock (_lock)
            {
                _tick += value;
                _count++;
                if (_count == 1)
                {
                    ScheduleNextFrame();
                }
            }
        }
        remove
        {
            lock (_lock)
            {
                _tick -= value;
                _count--;
            }
        }
    }

    internal IDisposable SubscribeView(AvaloniaView view)
    {
        lock (_lock)
        {
            _views.Add(view);
            if (_views.Count == 1)
            {
                ScheduleNextFrame();
            }
        }
        return Disposable.Create(
            () =>
            {
                lock (_lock)
                {
                    _views.Remove(view);
                }
            }
        );
    }

    private void Loop()
    {
        Looper.Prepare();
        _choreographer.SetResult(Choreographer.Instance!);
        Looper.Loop();
    }

    private void ScheduleNextFrame()
    {
        var choreographer = _choreographer.Task.Result;
        choreographer.PostFrameCallbackDelayed(this, CalculateNextFrameDelay());
    }

    private long CalculateNextFrameDelay()
    {
        if (_lastFrameTimeNanos == 0)
            return 0;

        long currentTimeNanos = Java.Lang.JavaSystem.NanoTime();
        long elapsedNanos = currentTimeNanos - _lastFrameTimeNanos;

        // If we have exceeded the target time, schedule the next frame immediately
        if (elapsedNanos >= _frameIntervalNanos)
            return 0;

        // Calculate the necessary wait time to maintain consistent timing
        return (_frameIntervalNanos - elapsedNanos) / 1000000; // Convert to milliseconds
    }

    public void DoFrame(long frameTimeNanos)
    {
        // Calculate the real delta time between frames
        TimeSpan deltaTime;
        if (_lastFrameTimeNanos > 0)
        {
            long deltaNanos = frameTimeNanos - _lastFrameTimeNanos;
            deltaTime = TimeSpan.FromTicks(deltaNanos / 100);
        }
        else
        {
            deltaTime = TimeSpan.FromTicks(frameTimeNanos / 100);
        }

        _lastFrameTimeNanos = frameTimeNanos;

        _tick?.Invoke(deltaTime);

        lock (_lock)
        {
            if (_count > 0 && _views.Count > 0)
            {
                ScheduleNextFrame();
            }
        }
    }

    public void Pause()
    {
        lock (_lock)
        {
            _isPaused = true;
        }
    }

    public void Resume()
    {
        lock (_lock)
        {
            _isPaused = false;
            if (_count > 0 && _views.Count > 0)
            {
                _choreographer.Task.Result.PostFrameCallback(this);
            }
        }
    }
}

[msneijders]

This link could help: https://github.com/AvaloniaUI/Avalonia/wiki/Using-private-apis-in-nuget-packages