Switch commoncpp2 to ucommon to solve dependency conflicts.
libccrtp was depending on commoncpp2, and have been replaced by a version
depending on ucommon as well.
diff --git a/jni/libucommon/sources/inc/ucommon/timers.h b/jni/libucommon/sources/inc/ucommon/timers.h
new file mode 100644
index 0000000..8208460
--- /dev/null
+++ b/jni/libucommon/sources/inc/ucommon/timers.h
@@ -0,0 +1,427 @@
+// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
+//
+// This file is part of GNU uCommon C++.
+//
+// GNU uCommon C++ is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GNU uCommon C++ is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Realtime timers and timer queues.
+ * This offers ucommon support for realtime high-resolution threadsafe
+ * timers and timer queues. Threads may be scheduled by timers and timer
+ * queues may be used to inject timer events into callback objects or through
+ * virtuals.
+ * @file ucommon/timers.h
+ */
+
+#ifndef _UCOMMON_TIMERS_H_
+#define _UCOMMON_TIMERS_H_
+
+#ifndef _UCOMMON_LINKED_H_
+#include <ucommon/linked.h>
+#endif
+
+#ifndef _MSWINDOWS_
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#include <time.h>
+
+NAMESPACE_UCOMMON
+
+/**
+ * Timer class to use when scheduling realtime events. The timer generally
+ * uses millisecond values but has a microsecond accuracy. On platforms that
+ * support it, the timer uses posix realtime monotonic clock extensions,
+ * otherwise lower accuracy timer systems might be used.
+ */
+class __EXPORT Timer
+{
+private:
+ friend class Conditional;
+ friend class Semaphore;
+ friend class Event;
+
+#if _POSIX_TIMERS > 0 && defined(POSIX_TIMERS)
+ timespec timer;
+#else
+#undef POSIX_TIMERS // make sure not used if no support
+ timeval timer;
+#endif
+ bool updated;
+
+protected:
+ /**
+ * Check if timer has been updated since last check.
+ * @return true if updated.
+ */
+ bool update(void);
+
+ /**
+ * Check if timer active.
+ * @return true if active.
+ */
+ bool is_active(void);
+
+public:
+#if _MSC_VER > 1400 // windows broken dll linkage issue...
+ static const timeout_t inf = ((timeout_t)(-1));
+ static const time_t reset = ((time_t)(0));
+#else
+ static const timeout_t inf; /**< A value to use for infinite time */
+ static const time_t reset; /**< A value to use when resetting */
+#endif
+
+#ifdef _MSWINDOWS_
+ typedef unsigned __int64 tick_t;
+#else
+ typedef uint64_t tick_t;
+#endif
+
+ /**
+ * Construct an untriggered timer set to the time of creation.
+ */
+ Timer();
+
+ /**
+ * Construct a triggered timer that expires at specified offset.
+ * @param offset to expire in milliseconds.
+ */
+ Timer(timeout_t offset);
+
+ /**
+ * Construct a triggered timer that expires at specified offset.
+ * @param offset to expire in seconds.
+ */
+ Timer(time_t offset);
+
+ /**
+ * Construct a timer from a copy of another timer.
+ * @param copy of timer to construct from.
+ */
+ Timer(const Timer& copy);
+
+ /**
+ * Set the timer to expire.
+ * @param expire time in milliseconds.
+ */
+ void set(timeout_t expire);
+
+ /**
+ * Set the timer to expire.
+ * @param expire time in seconds.
+ */
+ void set(time_t expire);
+
+ /**
+ * Set (update) the timer with current time.
+ */
+ void set(void);
+
+ /**
+ * Clear pending timer, has no value.
+ */
+ void clear(void);
+
+ /**
+ * Get remaining time until the timer expires.
+ * @return 0 if expired or milliseconds still waiting.
+ */
+ timeout_t get(void) const;
+
+ /**
+ * Get remaining time until timer expires by reference.
+ * @return 0 if expired or milliseconds still waiting.
+ */
+ inline timeout_t operator*() const
+ {return get();};
+
+ /**
+ * Check if timer has expired.
+ * @return true if timer still pending.
+ */
+ bool operator!() const;
+
+ /**
+ * Check if timer expired for is() expression.
+ * @return true if timer expired.
+ */
+ operator bool() const;
+
+ /**
+ * Set timer expiration.
+ * @param expire timer in specified seconds.
+ */
+ Timer& operator=(time_t expire);
+
+ /**
+ * Set timer expiration.
+ * @param expire timer in milliseconds.
+ */
+ Timer& operator=(timeout_t expire);
+
+ /**
+ * Adjust timer expiration.
+ * @param expire time to add in seconds.
+ */
+ Timer& operator+=(time_t expire);
+
+ /**
+ * Adjust timer expiration.
+ * @param expire time to add in milliseconds.
+ */
+ Timer& operator+=(timeout_t expire);
+
+ /**
+ * Adjust timer expiration.
+ * @param expire time to subtract in seconds.
+ */
+ Timer& operator-=(time_t expire);
+
+ /**
+ * Adjust timer expiration.
+ * @param expire time to subtract in milliseconds.
+ */
+ Timer& operator-=(timeout_t expire);
+
+ /**
+ * Compute difference between two timers.
+ * @param timer to use for difference.
+ * @return difference in milliseconds.
+ */
+ timeout_t operator-(const Timer& timer);
+
+ /**
+ * Compare timers if same timeout.
+ * @param timer to compare with.
+ * @return true if same.
+ */
+ bool operator==(const Timer& timer) const;
+
+ /**
+ * Compare timers if not same timeout.
+ * @param timer to compare with.
+ * @return true if not same.
+ */
+ bool operator!=(const Timer& timer) const;
+
+ /**
+ * Compare timers if earlier timeout than another timer.
+ * @param timer to compare with.
+ * @return true if earlier.
+ */
+ bool operator<(const Timer& timer) const;
+
+ /**
+ * Compare timers if earlier than or equal to another timer.
+ * @param timer to compare with.
+ * @return true if earlier or same.
+ */
+ bool operator<=(const Timer& timer) const;
+
+ /**
+ * Compare timers if later timeout than another timer.
+ * @param timer to compare with.
+ * @return true if later.
+ */
+ bool operator>(const Timer& timer) const;
+
+ /**
+ * Compare timers if later than or equal to another timer.
+ * @param timer to compare with.
+ * @return true if later or same.
+ */
+ bool operator>=(const Timer& timer) const;
+
+ /**
+ * Sleep current thread until the specified timer expires.
+ * @param timer to reference for sleep.
+ */
+ static void sync(Timer &timer);
+
+ /**
+ * Get timer ticks since uuid epoch.
+ * @return timer ticks in 100ns resolution.
+ */
+ static tick_t ticks(void);
+};
+
+/**
+ * A timer queue for timer events. The timer queue is used to hold a
+ * linked list of timers that must be processed together. The timer
+ * queue processes the timer event list and calls an expired function
+ * on events that have expired. The timer queue also determines the
+ * wait time until the next timer will expire. When timer events are
+ * modified, they can retrigger the queue to re-examine the list to
+ * find when the next timer will now expire.
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+class __EXPORT TimerQueue : public OrderedIndex
+{
+public:
+ /**
+ * A timer event object that lives on a timer queue. Timer events are
+ * triggered through the timer queue's expire method. Timer events
+ * also modify the queue when they are changed, particularly to force
+ * re-evaluation of the expiration period. This class is not used by
+ * itself but rather as a base class for a timer event object.
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+ class __EXPORT event : protected Timer, public LinkedList
+ {
+ protected:
+ friend class TimerQueue;
+
+ /**
+ * Construct a timer event object and initially arm.
+ * @param expire timer in specified milliseconds.
+ */
+ event(timeout_t expire);
+
+ /**
+ * Construct an armed timer event object and attach to queue.
+ * @param queue to add event to.
+ * @param expire timer in specified milliseconds.
+ */
+ event(TimerQueue *queue, timeout_t expire);
+
+ /**
+ * Event method to call in derived class when timer expires.
+ */
+ virtual void expired(void) = 0;
+
+ /**
+ * Expected next timeout for the timer. This may be overriden
+ * for strategy purposes when evaluted by timer queue's expire.
+ * @return milliseconds until timer next triggers.
+ */
+ virtual timeout_t timeout(void);
+
+ public:
+ /**
+ * Detaches from queue when destroyed.
+ */
+ virtual ~event();
+
+ /**
+ * Attach event to a timer queue. Detaches from previous list if
+ * already attached elsewhere.
+ * @param queue to attach to.
+ */
+ void attach(TimerQueue *queue);
+
+ /**
+ * Detach event from a timer queue.
+ */
+ void detach(void);
+
+ /**
+ * Arm event to trigger at specified timeout.
+ * @param timeout to expire and trigger.
+ */
+ void arm(timeout_t timeout);
+
+ /**
+ * Disarm event.
+ */
+ void disarm(void);
+
+ /**
+ * Time remaining until expired.
+ * @return milliseconds until timer expires.
+ */
+ inline timeout_t get(void) const
+ {return Timer::get();};
+
+ /**
+ * Notify timer queue that the timer has been updated.
+ */
+ void update(void);
+
+ /**
+ * Get the timer queue we are attached to.
+ * @return timer queue or NULL if not attached.
+ */
+ inline TimerQueue *list(void)
+ {return static_cast<TimerQueue*>(Root);};
+ };
+
+protected:
+ friend class event;
+
+ /**
+ * Called in derived class when the queue is being modified.
+ * This is often used to lock the list.
+ */
+ virtual void modify(void) = 0;
+
+ /**
+ * Called in derived class after the queue has been modified. This often
+ * releases a lock that modify set and to wakeup a timer thread to
+ * evaluate when the next timer will now expire.
+ */
+ virtual void update(void) = 0;
+
+public:
+ /**
+ * Create an empty timer queue.
+ */
+ TimerQueue();
+
+ /**
+ * Destroy queue, does not remove event objects.
+ */
+ virtual ~TimerQueue();
+
+ /**
+ * Add a timer event to the timer queue.
+ * @param timer event to add.
+ */
+ void operator+=(event &timer);
+
+ /**
+ * Remove a timer event from the timer queue.
+ * @param timer event to remove.
+ */
+ void operator-=(event &timer);
+
+ /**
+ * Process timer queue and find when next event triggers. This function
+ * will call the expired methods on expired timers. Normally this function
+ * will be called in the context of a timer thread which sleeps for the
+ * timeout returned unless it is awoken on an update event.
+ * @return timeout until next timer expires in milliseconds.
+ */
+ timeout_t expire();
+};
+
+/**
+ * A convenience type for timer queue timer events.
+ */
+typedef TimerQueue::event TQEvent;
+
+/**
+ * A convenience type for timers.
+ */
+typedef Timer timer_t;
+
+END_NAMESPACE
+
+extern "C" {
+#if defined(WIN32)
+ __EXPORT int gettimeofday(struct timeval *tv, void *tz);
+#endif
+}
+
+#endif