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/applog.h b/jni/libucommon/sources/inc/commoncpp/applog.h
new file mode 100644
index 0000000..b254a70
--- /dev/null
+++ b/jni/libucommon/sources/inc/commoncpp/applog.h
@@ -0,0 +1,585 @@
+// Copyright (C) 2005-2010 Angelo Naselli, Penta Engineering s.r.l.
+//
+// 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.
+//
+// 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/applog.h
+ * @short Application logging facilities abstraction.
+ **/
+
+
+#ifndef COMMONCPP_APPLOG_H_
+#define COMMONCPP_APPLOG_H_
+
+#ifndef COMMONCPP_SLOG_H_
+#include <commoncpp/slog.h>
+#endif
+
+#ifndef COMMONCPP_EXCEPTION_H_
+#include <commoncpp/exception.h>
+#endif
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <map>
+
+NAMESPACE_COMMONCPP
+using namespace std;
+/**
+ * Produces a dump of a buffer in a hexdump way with its
+ * code Ascii translation and relative buffer address.
+ *
+ * For instance:
+ * 0000000 - 77 98 21 49 0e 00 05 00 40 1c 01 1c 2f 00 00 00 w.!I....@.../...
+ *
+ */
+class __EXPORT HEXdump
+{
+ protected:
+ /**
+ * output string
+ */
+ std::string _str;
+
+ public:
+ // max_len: max number of bytes to be printed. 0 prints all.
+ /**
+ * HEXdump constructor.
+ *
+ * @param buffer buffer to be "hexdumped"
+ * @param buff_len buffer length
+ * @param max_len max number of bytes to be "hexdumped". Usefull to
+ * truncate output. mas_len=0 does prints all.
+ */
+ HEXdump(const unsigned char *buffer, int buff_len, int max_len = 200);
+
+ /**
+ * HEXdump destructor.
+ */
+ virtual ~HEXdump() { _str = string();}
+
+ /**
+ * const char* cast provided for conveneince.
+ */
+
+ const char * c_str() const
+ {
+ return _str.c_str();
+ }
+
+ /**
+ * string cast provided for conveneince.
+ */
+ std::string str()
+ {
+ return _str;
+ }
+
+ /**
+ * operator <<
+ * @param hd hexdump.
+ * @return application logger stream
+ */
+ friend std::ostream& operator<< (std::ostream& out, const HEXdump &hd)
+ {
+ out << hd.c_str();
+ return out;
+ }
+
+};
+
+#ifdef CCXX_EXCEPTIONS
+/**
+ * Applog exception, used for memory problems at the moment
+ *
+ */
+class __EXPORT AppLogException : public ost::Exception
+{
+ public:
+ /**
+ * Constructor.
+ * @param what_arg exception string
+ */
+ AppLogException(String &what_arg) : ost::Exception(what_arg) {};
+
+};
+#endif
+
+class AppLogPrivate;
+
+/**
+ * Application logger is a class that implements a logger that can be used
+ * by applications to save log file somewhere on the system.
+ *
+ * It uses ost::slog to write to syslog and std::clog to write to standard
+ * output.
+ *
+ * It provides either a stream oriented logger or a old printf style one.
+ *
+ * It can be used to log directly on a file or in a spooler like way. Latter
+ * uses a ost::ThreadQueue to implement a thread safe access to logger.
+ *
+ * It provides a global stream variable called ost::alog.
+ *
+ * It provides an AppLog::Ident class that represents a module name for
+ * instance that can be used to tag logs. Logging levels are the same
+ * defined into ost::Slog:
+ * Slog::levelEmergency
+ * Slog::levelAlert
+ * Slog::levelCritical
+ * Slog::levelError
+ * Slog::levelWarning
+ * Slog::levelNotice
+ * Slog::levelInfo
+ * Slog::levelDebugfrom.
+ *
+ * Example of usage: alog << mod_name << debug << "Hello world!" << std::endl;
+ */
+class __EXPORT AppLog : protected streambuf, public ostream
+{
+ protected:
+ // d pointer
+ AppLogPrivate *d;
+ void writeLog(bool endOfLine = true);
+ static std::map<string, Slog::Level> *assoc;
+
+ public:
+ /**
+ * Ident class that represents module name.
+ */
+ class __EXPORT Ident
+ {
+ private:
+ std::string _ident;
+ public:
+
+ /**
+ * Constructor.
+ */
+ Ident() {};
+
+ /**
+ * Desctructor.
+ */
+ ~Ident() {};
+
+ /**
+ * Copy constructor.
+ */
+ Ident(Ident& id) {_ident = id._ident;}
+
+ /**
+ * const char* constructor, provided for convenience.
+ */
+ Ident(const char *str) : _ident(str) {};
+
+ /**
+ * std::string cast.
+ */
+ std::string& str() {return _ident;}
+
+ /**
+ * Assignment operator (string).
+ */
+ Ident& operator= (std::string &st) {_ident = st; return *this;}
+
+ /**
+ * Assignment operator (const char[]), provided for convenience.
+ */
+ Ident& operator= (const char str[]) {_ident = str; return *this;}
+
+ /**
+ * const char* cast provided for conveneince.
+ */
+ const char* c_str() {return _ident.c_str();}
+ };
+
+#ifndef _MSWINDOWS_
+ /**
+ * Constructor for a customized logger.
+ * @param logFileName log file name.
+ * @param logDirectly true to write directly to file, false to use
+ * a spooler like logger.
+ * @param usePipe true to use pipe instead of file, false otherwise
+ */
+ AppLog(const char* logFileName = NULL, bool logDirectly = false , bool usePipe = false);
+#else
+ /**
+ * Constructor for a customized logger.
+ * @param logFileName log file name.
+ * @param logDirectly true to write directly to file, false to use
+ * a spooler like logger.
+ */
+ AppLog(const char* logFileName = NULL, bool logDirectly = false);
+#endif
+ /**
+ * Destructor
+ */
+ virtual ~AppLog();
+
+ /**
+ * Subscribes the current thread to logger, it reserves thread safe
+ * buffer for it.
+ */
+ void subscribe();
+
+ /**
+ * Unsubscribes the current thread from logger.
+ */
+ void unsubscribe();
+
+#ifndef _MSWINDOWS_
+ /**
+ * Allows to set up ost::alog parameters.
+ * @param FileName log file name.
+ * @param logDirectly true to write directly to file, false to use
+ * a spooler like logger.
+ * @param usePipe true to use pipe instead of file, false otherwise
+ */
+ void logFileName(const char* FileName, bool logDirectly = false, bool usePipe = false);
+#else
+ /**
+ * Allows to set up ost::alog parameters.
+ * @param FileName log file name.
+ * @param logDirectly true to write directly to file, false to use
+ * a spooler like logger.
+ */
+ void logFileName(const char* FileName, bool logDirectly = false);
+#endif
+ /**
+ * if logDirectly is set it closes the file.
+ */
+ void close(void);
+
+ /**
+ * Sets the log level.
+ * @param enable log level.
+ */
+ void level(Slog::Level enable);
+
+ /**
+ * Enables clog output.
+ * @param en true to enable clog output.
+ */
+ void clogEnable(bool en = true);
+
+ /**
+ * Enables slog output for error level messages.
+ * @param en true to enable slog output.
+ */
+ void slogEnable(bool en = true);
+
+ /**
+ * Sets the level for that ident.
+ * @param ident ident (module name for instance).
+ * @param level level
+ */
+ void identLevel(const char *ident, Slog::Level level);
+
+ /**
+ * Opens the file if not already and sets ident
+ * @param ident module name for instance.
+ */
+ void open(const char *ident);
+
+ /**
+ * stream overflow() overload.
+ * @param c character to be managed
+ * @return c
+ */
+ virtual int overflow(int c);
+
+ /**
+ * stream sync() overload
+ */
+ virtual int sync();
+
+ /**
+ * emerg level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void emerg(const char *format, ...);
+
+ /**
+ * alert level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void alert(const char *format, ...);
+
+ /**
+ * critical level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void critical(const char *format, ...);
+
+ /**
+ * error level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void error(const char *format, ...);
+
+ /**
+ * warn level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void warn(const char *format, ...);
+
+ /**
+ * notice level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void notice(const char *format, ...);
+
+ /**
+ * info level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void info(const char *format, ...);
+
+ /**
+ * debug level printf style method, provided for convenience.
+ * @param format printf format
+ */
+ void debug(const char *format, ...);
+
+ /**
+ * operator to change ident and log level
+ * @param ident ident (module name for instance)
+ * @param level new log level
+ * @return application logger stream
+ */
+ AppLog &operator()(const char *ident, Slog::Level level = Slog::levelError);
+
+ /**
+ * operator to change ident
+ * @param ident ident (module name for instance)
+ * @return application logger stream
+ */
+ inline AppLog& operator()(Ident &ident)
+ {
+ open(ident.c_str());
+ return *this;
+ }
+
+ /**
+ * operator to change logging level
+ * @param level new log level
+ * @return application logger stream
+ */
+ AppLog &operator()(Slog::Level level);
+
+ /**
+ * manipulator operator, to change print levels.
+ * @param (* pfManipulator)(AppLog &)
+ * @return application logger stream
+ */
+ AppLog& operator<< (AppLog& (*pfManipulator)(AppLog&));
+
+ /**
+ * manipulator operator, to use ostream manipulators (i.e. std::endl,...)
+ * @param (* pfManipulator)(AppLog &)
+ * @return application logger stream
+ */
+ AppLog& operator<< (ostream& (*pfManipulator)(ostream&));
+
+ friend ostream& operator << (ostream &os, AppLog & al)
+ {
+ return al;
+ }
+
+ /**
+ * operator <<
+ * @param ident module name for instance.
+ * @return application logger stream
+ */
+ inline AppLog& operator<< (Ident &ident)
+ {
+ open(ident.c_str());
+ return *this;
+ }
+
+
+ /**
+ * warn level
+ * @return application logger stream
+ */
+ inline AppLog &warn(void)
+ {return operator()(Slog::levelWarning);}
+
+ /**
+ * error level
+ * @return application logger stream
+ */
+ AppLog &error(void)
+ { return operator()(Slog::levelError);}
+
+ /**
+ * debug level
+ * @return application logger stream
+ */
+ inline AppLog &debug(void)
+ {return operator()(Slog::levelDebug);}
+
+ /**
+ * emerg level
+ * @return application logger stream
+ */
+ inline AppLog &emerg(void)
+ {return operator()(Slog::levelEmergency);}
+
+ /**
+ * alert level
+ * @return application logger stream
+ */
+ inline AppLog &alert(void)
+ {return operator()(Slog::levelAlert);}
+
+ /**
+ * critical level
+ * @return application logger stream
+ */
+ inline AppLog &critical(void)
+ {return operator()(Slog::levelCritical);}
+
+ /**
+ * notice level
+ * @return application logger stream
+ */
+ inline AppLog ¬ice(void)
+ {return operator()(Slog::levelNotice);}
+
+ /**
+ * info level
+ * @return application logger stream
+ */
+ inline AppLog &info(void)
+ {return operator()(Slog::levelInfo);}
+
+ /**
+ * Translates level from string to Slog::Level, useful for
+ * configuration files for instance.
+ * Valid level names are:
+ * "emerg" for Slog::levelEmergency
+ * "alert" for Slog::levelAlert
+ * "critical" for Slog::levelCritical
+ * "error" for Slog::levelError
+ * "warn" for Slog::levelWarning
+ * "notice" for Slog::levelNotice
+ * "info" for Slog::levelInfo
+ * "debug" for Slog::levelDebug
+ * @param name Slog Level name
+ * @return Slog level value
+ */
+ static Slog::Level levelTranslate(string name)
+ {
+ std::map<string, Slog::Level>::iterator it = assoc->find(name);
+ return (it != assoc->end()) ? it->second : Slog::levelEmergency;
+ }
+
+};
+
+/**
+ * Manipulator for debug level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &debug(AppLog& sl)
+{return sl.operator()(Slog::levelDebug);}
+
+/**
+ * Manipulator for warn level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &warn(AppLog& sl)
+{return sl.operator()(Slog::levelWarning);}
+
+/**
+ * Manipulator for error level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &error(AppLog& sl)
+{ return sl.operator()(Slog::levelError);}
+
+/**
+ * Manipulator for emerg level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &emerg(AppLog& sl)
+{return sl.operator()(Slog::levelEmergency);}
+
+/**
+ * Manipulator for alert level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &alert(AppLog& sl)
+{return sl.operator()(Slog::levelAlert);}
+
+/**
+ * Manipulator for critical level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &critical(AppLog& sl)
+{return sl.operator()(Slog::levelCritical);}
+
+/**
+ * Manipulator for notice level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog ¬ice(AppLog& sl)
+{return sl.operator()(Slog::levelNotice);}
+
+/**
+ * Manipulator for info level
+ * @param sl application logger stream
+ * @return application logger stream
+ */
+__EXPORT inline AppLog &info(AppLog& sl)
+{return sl.operator()(Slog::levelInfo);}
+
+/**
+ * alog global log stream definition
+ */
+__EXPORT extern AppLog alog;
+
+END_NAMESPACE
+
+#endif //___APPLOG_H___