Prevent Android timer from adding multiple callbacks;

Fixes #10257

src/Core/src/Dispatching/Dispatcher.Android.cs

@@ -1,5 +1,7 @@
 using System;
 using Android.OS;
+using Android.Systems;
+using Java.Lang;
 
 namespace Microsoft.Maui.Dispatching
 {
@@ -34,13 +36,20 @@ IDispatcherTimer CreateTimerImplementation()
 	partial class DispatcherTimer : IDispatcherTimer
 	{
 		readonly Handler _handler;
+		readonly IRunnable _runnable;
+
+		// For API versions after 29 and later, we can query the Handler directly to ask if callbacks
+		// are posted for our IRunnable. For API level before that, we'll need to manually track whether
+		// we've posted a callback to the queue.
+		bool _hasCallbacks;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
 		/// </summary>
 		/// <param name="handler">The handler for this dispatcher to use.</param>
 		public DispatcherTimer(Handler handler)
 		{
+			_runnable = new Runnable(OnTimerTick);
 			_handler = handler;
 		}
 
@@ -64,7 +73,7 @@ public void Start()
 
 			IsRunning = true;
 
-			_handler.PostDelayed(OnTimerTick, (long)Interval.TotalMilliseconds);
+			Post();
 		}
 
 		/// <inheritdoc/>
@@ -75,20 +84,63 @@ public void Stop()
 
 			IsRunning = false;
 
-			_handler.RemoveCallbacks(OnTimerTick);
+			_handler.RemoveCallbacks(_runnable);
+
+			SetHasCallbacks(false);
 		}
 
 		void OnTimerTick()
 		{
 			if (!IsRunning)
 				return;
 
+			SetHasCallbacks(false);
+
 			Tick?.Invoke(this, EventArgs.Empty);
 
 			if (IsRepeating)
-				_handler.PostDelayed(OnTimerTick, (long)Interval.TotalMilliseconds);
+			{
+				Post();
+			}
 			else
+			{
 				Stop();
+			}
+		}
+
+		void Post()
+		{
+			if (IsCallbackPosted())
+			{
+				return;
+			}
+
+			_handler.PostDelayed(_runnable, (long)Interval.TotalMilliseconds);
+
+			SetHasCallbacks(true);
+		}
+
+		bool IsCallbackPosted()
+		{
+			if (OperatingSystem.IsAndroidVersionAtLeast(29))
+			{
+				return _handler.HasCallbacks(_runnable);
+			}
+
+			// Below API 29 we'll manually track whether there's a posted callback
+			return _hasCallbacks;
+		}
+
+		void SetHasCallbacks(bool hasCallbacks)
+		{
+			if (OperatingSystem.IsAndroidVersionAtLeast(29))
+			{
+				return;
+			}
+
+			// We only need to worry about tracking this if we're below API 29; after that,
+			// we can just ask the Handler with the HasCallBacks() method. 
+			_hasCallbacks = hasCallbacks;
 		}
 	}
 

src/Core/tests/DeviceTests/Services/Dispatching/DispatcherTests.cs

@@ -233,6 +233,45 @@ await InvokeOnMainThreadAsync(async () =>
 			});
 		}
 
+		[Fact]
+		public async Task TimerCannotDoubleItself()
+		{
+			// This is a test specifically for the situation in https://github.com/dotnet/maui/issues/10257
+			// where the user is calling the timer's Stop/Start methods from the Tick handler, and thus
+			// exponentially increasing the number of handlers.
+
+			await InvokeOnMainThreadAsync(async () =>
+			{
+				var dispatcher = Dispatcher.GetForCurrentThread();
+
+				var ticks = 0;
+				
+				var timer = dispatcher.CreateTimer();
+				using var disposer = new TimerDisposer(timer);
+
+				Assert.False(timer.IsRunning);
+
+				timer.Interval = TimeSpan.FromMilliseconds(200);
+				timer.IsRepeating = true;
+
+				timer.Tick += (_, _) =>
+				{
+					ticks += 1;
+					timer.Stop();
+					timer.Start();
+				};
+
+				timer.Start();
+
+				await Task.Delay(TimeSpan.FromSeconds(1.1));
+
+				// The actual number may vary a bit depending on timing, but 
+				// if the bug is present then ticks will be roughly 2^5, rather than 
+				// the expected value of about 5 
+				Assert.True(10 > ticks); 
+			});
+		}
+
 		class TimerDisposer : IDisposable
 		{
 			IDispatcherTimer _timer;