CODEWITHSUNDEEP
c#androidxamarintimer
who's.asking
who's.asking

Reputation: 83

How do I add a timer in Xamarin?

So I need to have a timer to count down from 60 seconds. I am new to Xamarin and have no idea what it accepts. It will be used in Android.

Any suggestions on how to start?

Can you use System.Timers.Timer?

Upvotes: 6

Views: 29165

Answers (4)

Robbit
Robbit

Reputation: 4358

Yes, you can use System.Timers.Timer.

In Android we can use java.util.Timer like this:

    private int i;

    final Timer timer=new Timer();
    TimerTask task=new TimerTask() {
        @Override
        public void run() {
            if (i < 60) {
                i++;
            } else {
                timer.cancel();
            }
            Log.e("time=",i+"");
        }
    };
    timer.schedule(task, 0,1000);

In Xamarin.Android we can also use java.util.Timer like this:

[Activity(Label = "Tim", MainLauncher = true)]
public class MainActivity : Activity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        // Set our view from the "main" layout resource
        SetContentView(Resource.Layout.Main);
        Timer timer = new Timer();
        timer.Schedule(new MyTask(timer),0,1000);
    }
}

class MyTask : TimerTask
{
    Timer mTimer;
    public MyTask(Timer timer) {
        this.mTimer = timer;
    }
    int i;
    public override void Run()
    {
        if (i < 60)
        {
            i++;
        }
        else {
            mTimer.Cancel();
        }

        Android.Util.Log.Error("time",i+"");
    }
}

Upvotes: 3

William Obando
William Obando

Reputation: 31

You can always use 

Task.Factory.StartNewTaskContinuously(YourMethod, new CancellationToken(), TimeSpan.FromMinutes(10));

Be sure to add the following class to your project

static class Extensions
{
    /// <summary>
    /// Start a new task that will run continuously for a given amount of time.
    /// </summary>
    /// <param name="taskFactory">Provides access to factory methods for creating System.Threading.Tasks.Task and System.Threading.Tasks.Task`1 instances.</param>
    /// <param name="action">The action delegate to execute asynchronously.</param>
    /// <param name="cancellationToken">The System.Threading.Tasks.TaskFactory.CancellationToken that will be assigned to the new task.</param>
    /// <param name="timeSpan">The interval between invocations of the callback.</param>
    /// <returns>The started System.Threading.Tasks.Task.</returns>
    public static Task StartNewTaskContinuously(this TaskFactory taskFactory, Action action, CancellationToken cancellationToken, TimeSpan timeSpan
        , string taskName = "")
    {
        return taskFactory.StartNew(async () =>
        {
            if (!string.IsNullOrEmpty(taskName))
            {
                Debug.WriteLine("Started task " + taskName);
            }
            while (!cancellationToken.IsCancellationRequested)
            {
                action();
                try
                {
                    await Task.Delay(timeSpan, cancellationToken);
                }
                catch (Exception e)
                {
                    break;
                }
            }
            if (!string.IsNullOrEmpty(taskName))
            {
                Debug.WriteLine("Finished task " + taskName);
            }
        });
    }
}

Upvotes: 0

Markus
Markus

Reputation: 2281

If you just need Android you can use 

System.Threading.Timer

In shared code with Xamarin Forms you can use 

Device.StartTimer(...)

Or you can implement one yourselfe with advanced features like:

public sealed class Timer : CancellationTokenSource {
    private readonly Action _callback;
    private int _millisecondsDueTime;
    private readonly int _millisecondsPeriod;

    public Timer(Action callback, int millisecondsDueTime) {
        _callback = callback;
        _millisecondsDueTime = millisecondsDueTime;
        _millisecondsPeriod = -1;
        Start();
    }

    public Timer(Action callback, int millisecondsDueTime, int millisecondsPeriod) {
        _callback = callback;
        _millisecondsDueTime = millisecondsDueTime;
        _millisecondsPeriod = millisecondsPeriod;
        Start();
    }

    private void Start() {
        Task.Run(() => {
            if (_millisecondsDueTime <= 0) {
                _millisecondsDueTime = 1;
            }
            Task.Delay(_millisecondsDueTime, Token).Wait();
            while (!IsCancellationRequested) {

                //TODO handle Errors - Actually the Callback should handle the Error but if not we could do it for the callback here
                _callback();

                if(_millisecondsPeriod <= 0) break;

                if (_millisecondsPeriod > 0 && !IsCancellationRequested) {
                    Task.Delay(_millisecondsPeriod, Token).Wait();
                }
            }
        });
    }

    public void Stop() {
        Cancel();
    }

    protected override void Dispose(bool disposing) {
        if (disposing) {
            Cancel();
        }
        base.Dispose(disposing);
    }

}

Upvotes: 3

Sigge
Sigge

Reputation: 2172

You can use the System.Threading.Timer class, which is documented in the Xamarin docs: https://developer.xamarin.com/api/type/System.Threading.Timer/

Alternatively, for Xamarin.Forms, you have access to a cross-platform Timer via the Device class:

Device.StartTimer(TimeSpan.FromSeconds(1), () =>
{
    // called every 1 second
    // do stuff here

    return true; // return true to repeat counting, false to stop timer
});

Upvotes: 10

Related Questions