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/commoncpp/dccp.h b/jni/libucommon/sources/inc/commoncpp/dccp.h
new file mode 100644
index 0000000..e6ce8e9
--- /dev/null
+++ b/jni/libucommon/sources/inc/commoncpp/dccp.h
@@ -0,0 +1,227 @@
+// Copyright (C) 1999-2005 Open Source Telecom Corporation.
+// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+//
+// This exception applies only to the code released under the name GNU
+// Common C++. If you copy code from other releases into a copy of GNU
+// Common C++, as the General Public License permits, the exception does
+// not apply to the code that you add in this way. To avoid misleading
+// anyone as to the status of such modified files, you must delete
+// this exception notice from them.
+//
+// If you write modifications of your own for GNU Common C++, it is your choice
+// whether to permit this exception to apply to your modifications.
+// If you do not wish that, delete this exception notice.
+//
+
+/**
+ * @file commoncpp/udp.h
+ * @short udp derived socket classes.
+ **/
+
+#ifndef COMMONCPP_DCCP_H_
+#define COMMONCPP_DCCP_H_
+
+#include <cstdio>
+
+#ifndef COMMONCPP_CONFIG_H_
+#include <commoncpp/config.h>
+#endif
+
+#ifndef COMMONCPP_STRING_H_
+#include <commoncpp/string.h>
+#endif
+
+#ifndef COMMONCPP_ADDRESS_H_
+#include <commoncpp/address.h>
+#endif
+
+#ifndef COMMONCPP_SOCKET_H_
+#include <commoncpp/socket.h>
+#endif
+
+NAMESPACE_COMMONCPP
+
+/**
+ * DCCP sockets are used for stream based connected sessions between two
+ * sockets. Both error recovery and flow control operate transparently
+ * for a DCCP socket connection. The DCCP socket base class is used both
+ * for client connections and to bind a DCCP "server" for accepting DCCP
+ * streams.
+ *
+ * An implicit and unique DCCPSocket object exists in Common C++ to represent
+ * a bound DCCP socket acting as a "server" for receiving connection requests.
+ * This class is not part of DCCPStream because such objects normally perform
+ * no physical I/O (read or write operations) other than to specify a listen
+ * backlog queue and perform "accept" operations for pending connections.
+ * The Common C++ DCCPSocket offers a Peek method to examine where the next
+ * pending connection is coming from, and a Reject method to flush the next
+ * request from the queue without having to create a session.
+ *
+ * The DCCPSocket also supports a "OnAccept" method which can be called when a
+ * DCCPStream related object is created from a DCCPSocket. By creating a
+ * DCCPStream from a DCCPSocket, an accept operation automatically occurs, and
+ * the DCCPSocket can then still reject the client connection through the
+ * return status of it's OnAccept method.
+ *
+ * @author Leandro Sales <leandroal@gmail.com>
+ * @author Heverton Stuart <hevertonsns@gmail.com>
+ * @short bound server for DCCP streams and sessions.
+ */
+class __EXPORT DCCPSocket : public Socket
+{
+ union {
+ struct sockaddr_in ipv4;
+#ifdef CCXX_IPV6
+ struct sockaddr_in6 ipv6;
+#endif
+ } peer;
+
+ Family family;
+
+public:
+ /**
+ * A method to call in a derived DCCPSocket class that is acting
+ * as a server when a connection request is being accepted. The
+ * server can implement protocol specific rules to exclude the
+ * remote socket from being accepted by returning false. The
+ * Peek method can also be used for this purpose.
+ *
+ * @return true if client should be accepted.
+ * @param ia internet host address of the client.
+ * @param port number of the client.
+ */
+ virtual bool onAccept(const IPV4Host &ia, tpport_t port);
+#ifdef CCXX_IPV6
+ virtual bool onAccept(const IPV6Host &ia, tpport_t port);
+#endif
+
+ virtual IPV4Host getIPV4Sender(tpport_t *port = NULL) const;
+
+#ifdef CCXX_IPV6
+ virtual IPV6Host getIPV6Sender(tpport_t *port = NULL) const;
+#endif
+
+ /**
+ * A DCCP "server" is created as a DCCP socket that is bound
+ * to a hardware address and port number on the local machine
+ * and that has a backlog queue to listen for remote connection
+ * requests. If the server cannot be created, an exception is
+ * thrown.
+ *
+ * @param bind local ip address or interface to use.
+ * @param port number to bind socket under.
+ * @param backlog size of connection request queue.
+ */
+ DCCPSocket(const IPV4Address &bind, tpport_t port, unsigned backlog = 5);
+#ifdef CCXX_IPV6
+ DCCPSocket(const IPV6Address &bind, tpport_t port, unsigned backlog = 5);
+#endif
+
+ /**
+ * Create a named dccp socket by service and/or interface id.
+ * For IPV4 we use [host:]svc or [host/]svc for the string.
+ * If we have getaddrinfo, we use that to obtain the addr to
+ * bind for.
+ *
+ * @param name of host interface and service port to bind.
+ * @param backlog size of connection request queue.
+ */
+ DCCPSocket(const char *name, Family family = IPV4, unsigned backlog = 5);
+
+ /**
+ * Create an unconnected ephemeral DCCP client socket.
+ */
+ DCCPSocket(Family family = IPV4);
+
+ /**
+ * Create a server session by accepting a DCCP Socket.
+ */
+ DCCPSocket(DCCPSocket& server, timeout_t timeout = 0);
+
+ /**
+ * Used to reject the next incoming connection request.
+ */
+ void reject(void);
+
+ /**
+ * Disconnect active dccp connection (client use).
+ */
+ void disconnect(void);
+
+ /**
+ * Set CCID DCCP.
+ */
+ bool setCCID(uint8_t ccid);
+
+ /**
+ * Get TX CCID DCCP.
+ */
+ int getTxCCID();
+
+ /**
+ * Get RX CCID DCCP.
+ */
+ int getRxCCID();
+
+ /**
+ * Return number of bytes to be read
+ */
+ size_t available();
+
+ /**
+ * Create a DCCP client connection to a DCCP socket (on
+ * a remote machine).
+ *
+ * @param host address of remote DCCP server.
+ * @param port number to connect.
+ */
+ void connect(const IPV4Host &host, tpport_t port, timeout_t timeout = 0);
+#ifdef CCXX_IPV6
+ void connect(const IPV6Host &host, tpport_t port, timeout_t timeout = 0);
+#endif
+
+ /**
+ * Connect to a named client.
+ */
+ void connect(const char *name);
+
+ /**
+ * Used to wait for pending connection requests.
+ * @return true if data packets available.
+ * @param timeout in milliseconds. TIMEOUT_INF if not specified.
+ */
+ inline bool isPendingConnection(timeout_t timeout = TIMEOUT_INF) /* not const -- jfc */
+ {return Socket::isPending(Socket::pendingInput, timeout);}
+
+ /**
+ * Use base socket handler for ending this socket.
+ */
+ virtual ~DCCPSocket();
+};
+
+END_NAMESPACE
+
+#endif