Ryujinx/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/TimedAction.cs
Mary 57d3296ba4
infra: Migrate to .NET 6 (#2829)
* infra: Migrate to .NET 6

* Rollback version naming change

* Workaround .NET 6 ZipArchive API issues

* ci: Switch to VS 2022 for AppVeyor

CI is now ready for .NET 6

* Suppress WebClient warning in DoUpdateWithMultipleThreads

* Attempt to workaround System.Drawing.Common changes on 6.0.0

* Change keyboard rendering from System.Drawing to ImageSharp

* Make the software keyboard renderer multithreaded

* Bump ImageSharp version to 1.0.4 to fix a bug in Image.Load

* Add fallback fonts to the keyboard renderer

* Fix warnings

* Address caian's comment

* Clean up linux workaround as it's uneeded now

* Update readme

Co-authored-by: Caian Benedicto <caianbene@gmail.com>
2021-11-28 21:24:17 +01:00

186 lines
5.2 KiB
C#

using System;
using System.Threading;
namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{
/// <summary>
/// A threaded executor of periodic actions that can be cancelled. The total execution time is optional
/// and, in this case, a progress is reported back to the action.
/// </summary>
class TimedAction
{
public const int MaxThreadSleep = 100;
private class SleepSubstepData
{
public readonly int SleepMilliseconds;
public readonly int SleepCount;
public readonly int SleepRemainderMilliseconds;
public SleepSubstepData(int sleepMilliseconds)
{
SleepMilliseconds = Math.Min(sleepMilliseconds, MaxThreadSleep);
SleepCount = sleepMilliseconds / SleepMilliseconds;
SleepRemainderMilliseconds = sleepMilliseconds - SleepCount * SleepMilliseconds;
}
}
private TRef<bool> _cancelled = null;
private Thread _thread = null;
private object _lock = new object();
public bool IsRunning
{
get
{
lock (_lock)
{
if (_thread == null)
{
return false;
}
return _thread.IsAlive;
}
}
}
public void RequestCancel()
{
lock (_lock)
{
if (_cancelled != null)
{
Volatile.Write(ref _cancelled.Value, true);
}
}
}
public TimedAction() { }
private void Reset(Thread thread, TRef<bool> cancelled)
{
lock (_lock)
{
// Cancel the current task.
if (_cancelled != null)
{
Volatile.Write(ref _cancelled.Value, true);
}
_cancelled = cancelled;
_thread = thread;
_thread.IsBackground = true;
_thread.Start();
}
}
public void Reset(Action<float> action, int totalMilliseconds, int sleepMilliseconds)
{
// Create a dedicated cancel token for each task.
var cancelled = new TRef<bool>(false);
Reset(new Thread(() =>
{
var substepData = new SleepSubstepData(sleepMilliseconds);
int totalCount = totalMilliseconds / sleepMilliseconds;
int totalRemainder = totalMilliseconds - totalCount * sleepMilliseconds;
if (Volatile.Read(ref cancelled.Value))
{
action(-1);
return;
}
action(0);
for (int i = 1; i <= totalCount; i++)
{
if (SleepWithSubstep(substepData, cancelled))
{
action(-1);
return;
}
action((float)(i * sleepMilliseconds) / totalMilliseconds);
}
if (totalRemainder > 0)
{
if (SleepWithSubstep(substepData, cancelled))
{
action(-1);
return;
}
action(1);
}
}), cancelled);
}
public void Reset(Action action, int sleepMilliseconds)
{
// Create a dedicated cancel token for each task.
var cancelled = new TRef<bool>(false);
Reset(new Thread(() =>
{
var substepData = new SleepSubstepData(sleepMilliseconds);
while (!Volatile.Read(ref cancelled.Value))
{
action();
if (SleepWithSubstep(substepData, cancelled))
{
return;
}
}
}), cancelled);
}
public void Reset(Action action)
{
// Create a dedicated cancel token for each task.
var cancelled = new TRef<bool>(false);
Reset(new Thread(() =>
{
while (!Volatile.Read(ref cancelled.Value))
{
action();
}
}), cancelled);
}
private static bool SleepWithSubstep(SleepSubstepData substepData, TRef<bool> cancelled)
{
for (int i = 0; i < substepData.SleepCount; i++)
{
if (Volatile.Read(ref cancelled.Value))
{
return true;
}
Thread.Sleep(substepData.SleepMilliseconds);
}
if (substepData.SleepRemainderMilliseconds > 0)
{
if (Volatile.Read(ref cancelled.Value))
{
return true;
}
Thread.Sleep(substepData.SleepRemainderMilliseconds);
}
return Volatile.Read(ref cancelled.Value);
}
}
}