summaryrefslogtreecommitdiff
path: root/platform/default/timer.cpp
blob: cd0e6da6aa7b7acf75b80db04ed8b1b7416e2803 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <mbgl/util/timer.hpp>

#include <mbgl/util/run_loop.hpp>

#include <uv.h>

namespace mbgl {
namespace util {

class Timer::Impl {
public:
    Impl() : timer(new uv_timer_t) {
        uv_loop_t* loop = reinterpret_cast<uv_loop_t*>(RunLoop::getLoopHandle());
        if (uv_timer_init(loop, timer) != 0) {
            throw std::runtime_error("Failed to initialize timer.");
        }

        handle()->data = this;
        uv_unref(handle());
    }

    ~Impl() {
        uv_close(handle(), [](uv_handle_t* h) {
            delete reinterpret_cast<uv_timer_t*>(h);
        });
    }

    void start(uint64_t timeout, uint64_t repeat, std::function<void ()>&& cb_) {
        cb = std::move(cb_);
        if (uv_timer_start(timer, timerCallback, timeout, repeat) != 0) {
            throw std::runtime_error("Failed to start timer.");
        }
    }

    void stop() {
        cb = nullptr;
        if (uv_timer_stop(timer) != 0) {
            throw std::runtime_error("Failed to stop timer.");
        }
    }

private:
    static void timerCallback(uv_timer_t* handle) {
        reinterpret_cast<Impl*>(handle->data)->cb();
    }

    uv_handle_t* handle() {
        return reinterpret_cast<uv_handle_t*>(timer);
    }

    uv_timer_t* timer;

    std::function<void()> cb;
};

Timer::Timer()
    : impl(std::make_unique<Impl>()) {
}

Timer::~Timer() = default;

void Timer::start(Duration timeout, Duration repeat, std::function<void()>&& cb) {
    impl->start(std::chrono::duration_cast<Milliseconds>(timeout).count(),
                std::chrono::duration_cast<Milliseconds>(repeat).count(),
                std::move(cb));
}

void Timer::stop() {
    impl->stop();
}

} // namespace util
} // namespace mbgl