[A]add sdk_core.

sdk_core/src/base/command_callback.h

@@ -0,0 +1,245 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_COMMAND_CALLBACK_H
+#define LIVOX_COMMAND_CALLBACK_H
+
+#include <boost/function.hpp>
+#include <boost/smart_ptr.hpp>
+#include "livox_sdk.h"
+
+namespace livox {
+
+class CommandCallback {
+ public:
+  virtual ~CommandCallback() {}
+  virtual void operator()(uint8_t handle, void *data) = 0;
+};
+
+template <class T, class ResponseType>
+class MemberFunctionCallback : public CommandCallback {
+ public:
+  typedef void (T::*MemFn)(uint8_t status, uint8_t handle, ResponseType *data);
+
+  MemberFunctionCallback(T *cls, MemFn func) : this_(cls), func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (this_) {
+      (this_->*func_)((data == NULL) ? kStatusTimeout : kStatusSuccess, handle, static_cast<ResponseType *>(data));
+    }
+  }
+
+ private:
+  T *this_;
+  MemFn func_;
+};
+
+template <class T>
+class MemberFunctionCallback<T, uint8_t> : public CommandCallback {
+ public:
+  typedef void (T::*MemFn)(uint8_t status, uint8_t handle, uint8_t response);
+
+  MemberFunctionCallback(T *cls, MemFn func) : this_(cls), func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (this_) {
+      (this_->*func_)((data == NULL) ? kStatusTimeout : kStatusSuccess,
+                      handle,
+                      static_cast<uint8_t>(reinterpret_cast<uintptr_t>(data)));
+    }
+  }
+
+ private:
+  T *this_;
+  MemFn func_;
+};
+
+template <class T, class ResponseType>
+boost::shared_ptr<CommandCallback> MakeCommandCallback(T *cls,
+                                                       typename MemberFunctionCallback<T, ResponseType>::MemFn func) {
+  boost::shared_ptr<CommandCallback> cb(new MemberFunctionCallback<T, ResponseType>(cls, func));
+  return cb;
+}
+
+template <class T>
+class FunctionStatusCallback : public CommandCallback {
+ public:
+  typedef void (*Fn)(uint8_t status, uint8_t handle, T *data, void *client_data);
+
+ public:
+  FunctionStatusCallback(Fn func, void *client_data) : func_(func), client_data_(client_data) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      (*func_)((data == NULL) ? kStatusTimeout : kStatusSuccess, handle, static_cast<T *>(data), client_data_);
+    }
+  }
+
+ private:
+  Fn func_;
+  void *client_data_;
+};
+
+template <>
+class FunctionStatusCallback<uint8_t> : public CommandCallback {
+ public:
+  typedef void (*Fn)(uint8_t status, uint8_t handle, uint8_t data, void *client_data);
+
+ public:
+  FunctionStatusCallback(Fn func, void *client_data) : func_(func), client_data_(client_data) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      if (data == NULL) {
+        (*func_)(kStatusTimeout, handle, 0, client_data_);
+      } else {
+        (*func_)(kStatusSuccess, handle, *(uint8_t *)data, client_data_);
+      }
+    }
+  }
+
+ private:
+  Fn func_;
+  void *client_data_;
+};
+
+template <class T>
+boost::shared_ptr<CommandCallback> MakeCommandCallback(typename FunctionStatusCallback<T>::Fn func, void *client_data) {
+  boost::shared_ptr<CommandCallback> cb(new FunctionStatusCallback<T>(func, client_data));
+  return cb;
+}
+
+template <class T>
+class MessageCallback : public CommandCallback {
+ public:
+  typedef void (*Fn)(uint8_t handle, T *data);
+
+ public:
+  MessageCallback(const Fn &func) : func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      (*func_)(handle, static_cast<T *>(data));
+    }
+  }
+
+ private:
+  Fn func_;
+};
+
+template <class ResponseType>
+class BoostFunctionMessageCallback : public CommandCallback {
+ public:
+  typedef boost::function<void(uint8_t, ResponseType *)> Fn;
+
+ public:
+  BoostFunctionMessageCallback(const Fn &func) : func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      func_(handle, static_cast<ResponseType *>(data));
+    }
+  }
+
+ private:
+  Fn func_;
+};
+
+template <class T>
+boost::shared_ptr<CommandCallback> MakeMessageCallback(typename MessageCallback<T>::Fn func) {
+  boost::shared_ptr<CommandCallback> cb(new MessageCallback<T>(func));
+  return cb;
+}
+
+template <class T>
+boost::shared_ptr<CommandCallback> MakeMessageCallback(typename BoostFunctionMessageCallback<T>::Fn func) {
+  boost::shared_ptr<CommandCallback> cb(new BoostFunctionMessageCallback<T>(func));
+  return cb;
+}
+
+template <class T, class ResponseType>
+class MemberMessageCallback : public CommandCallback {
+ public:
+  typedef void (T::*MemFn)(uint8_t handle, ResponseType *data);
+
+  MemberMessageCallback(T *cls, MemFn func) : this_(cls), func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (this_) {
+      (this_->*func_)(handle, (ResponseType *)data);
+    }
+  }
+
+ private:
+  T *this_;
+  MemFn func_;
+};
+
+template <class T, class ResponseType>
+boost::shared_ptr<CommandCallback> MakeMemberMessageCallback(
+    T *_this,
+    typename MemberMessageCallback<T, ResponseType>::MemFn func) {
+  boost::shared_ptr<CommandCallback> cb(new MemberMessageCallback<T, ResponseType>(_this, func));
+  return cb;
+}
+
+template <class ResponseType>
+class BoostFunctionCallback : public CommandCallback {
+ public:
+  typedef boost::function<void(uint8_t, uint8_t, ResponseType *)> Fn;
+  BoostFunctionCallback(const Fn &func) : func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      if (data == NULL) {
+        func_(kStatusTimeout, handle, NULL);
+      } else {
+        func_(kStatusSuccess, handle, (ResponseType *)data);
+      }
+    }
+  }
+
+ private:
+  Fn func_;
+};
+
+template <>
+class BoostFunctionCallback<uint8_t> : public CommandCallback {
+ public:
+  typedef boost::function<void(uint8_t, uint8_t, uint8_t)> Fn;
+  BoostFunctionCallback(const Fn &func) : func_(func) {}
+  void operator()(uint8_t handle, void *data) {
+    if (func_) {
+      if (data == NULL) {
+        func_(kStatusTimeout, handle, 0);
+      } else {
+        func_(kStatusSuccess, handle, static_cast<uint8_t>(reinterpret_cast<uintptr_t>(data)));
+      }
+    }
+  }
+
+ private:
+  Fn func_;
+};
+
+template <class ResponseType>
+boost::shared_ptr<CommandCallback> MakeCommandCallback(const typename BoostFunctionCallback<ResponseType>::Fn &func) {
+  boost::shared_ptr<CommandCallback> cb(new BoostFunctionCallback<ResponseType>(func));
+  return cb;
+}
+
+}  // namespace livox
+#endif  // LIVOX_COMMAND_CALLBACK_H

sdk_core/src/base/io_loop.cpp

@@ -0,0 +1,182 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "io_loop.h"
+#include <boost/bind.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/locks.hpp>
+#include <iostream>
+#include "logging.h"
+
+using boost::lock_guard;
+using boost::mutex;
+using std::vector;
+
+namespace livox {
+
+bool IOLoop::Init() {
+  if (mem_pool_ == NULL) {
+    return false;
+  }
+  apr_status_t rv =
+      apr_pollset_create(&pollset_, kMaxPollCount, mem_pool_, APR_POLLSET_THREADSAFE | APR_POLLSET_WAKEABLE);
+  if (rv != APR_SUCCESS) {
+    LOG_ERROR << PrintAPRStatus(rv) << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+void IOLoop::Uninit() {
+  if (pollset_) {
+    apr_pollset_destroy(pollset_);
+    pollset_ = NULL;
+  }
+
+  for (DelegatesType::const_iterator ite = delegates_.begin(); ite != delegates_.end(); ++ite) {
+    ClientData *data = ite->second;
+    if (data) {
+      delete data;
+    }
+  }
+
+  delegates_.clear();
+  mem_pool_ = NULL;
+}
+
+void IOLoop::AddDelegate(apr_socket_t *sock, IOLoop::IOLoopDelegate *delegate, void *data) {
+  PostTask(boost::bind(&IOLoop::AddDelegateAsync, this, sock, delegate, data));
+}
+
+void IOLoop::RemoveDelegate(apr_socket_t *sock, IOLoopDelegate *) {
+  PostTask(boost::bind(&IOLoop::RemoveDelegateAsync, this, sock));
+}
+
+void IOLoop::Loop() {
+  apr_int32_t num = 0;
+  const apr_pollfd_t *ret_pfd = NULL;
+  apr_status_t rv = apr_pollset_poll(pollset_, apr_time_from_msec(50), &num, &ret_pfd);
+
+  if (rv == APR_SUCCESS) {
+    for (int i = 0; i < num; i++) {
+      ClientData *data = static_cast<ClientData *>(ret_pfd[i].client_data);
+      ;
+      if (data) {
+        IOLoopDelegate *delegate = data->first;
+        if (delegate) {
+          delegate->OnData(ret_pfd->desc.s, data->second);
+        }
+      }
+    }
+  }
+
+  if (enable_wake_ && APR_STATUS_IS_EINTR(rv)) {
+    DelegatesType delegates = delegates_;
+    for (DelegatesType::const_iterator ite = delegates.begin(); ite != delegates.end(); ++ite) {
+      ClientData *data = ite->second;
+      if (data) {
+        IOLoopDelegate *delegate = data->first;
+        if (delegate) {
+          delegate->OnWake();
+        }
+      }
+    }
+  }
+
+  if (enable_timer_) {
+    apr_time_t t = apr_time_now();
+    if (last_timeout_ == 0 || t - last_timeout_ > apr_time_from_msec(50)) {
+      last_timeout_ = t;
+      // copy delegates_ in case delegate is removed in callback.
+      DelegatesType delegates = delegates_;
+      for (DelegatesType::const_iterator ite = delegates.begin(); ite != delegates.end(); ++ite) {
+        ClientData *data = ite->second;
+        if (data) {
+          IOLoopDelegate *delegate = data->first;
+          if (delegate) {
+            delegate->OnTimer(t);
+          }
+        }
+      }
+    }
+  }
+
+  vector<IOLoopTask> tasks;
+  {
+    lock_guard<mutex> lock(mutex_);
+    tasks.swap(pending_tasks_);
+  }
+
+  for (vector<IOLoopTask>::iterator ite = tasks.begin(); ite != tasks.end(); ++ite) {
+    IOLoopTask &task = *ite;
+    task();
+  }
+
+  if (rv != APR_SUCCESS && !APR_STATUS_IS_TIMEUP(rv) && !APR_STATUS_IS_EINTR(rv)) {
+    LOG_ERROR << PrintAPRStatus(rv) << std::endl;
+  }
+}
+
+bool IOLoop::Wakeup() {
+  apr_status_t rv = apr_pollset_wakeup(pollset_);
+  if (rv != APR_SUCCESS) {
+    LOG_ERROR << PrintAPRStatus(rv) << std::endl;
+    return false;
+  }
+  return true;
+}
+
+void IOLoop::PostTask(const IOLoopTask &task) {
+  {
+    lock_guard<mutex> lock(mutex_);
+    pending_tasks_.push_back(task);
+  }
+  Wakeup();
+}
+
+void IOLoop::AddDelegateAsync(apr_socket_t *sock, IOLoop::IOLoopDelegate *delegate, void *data) {
+  ClientData *p = new ClientData(delegate, data);
+  apr_pollfd_t pfd = {mem_pool_, APR_POLL_SOCKET, APR_POLLIN, 0, {NULL}, p};
+  pfd.desc.s = sock;
+  apr_pollset_add(pollset_, &pfd);
+  delegates_[sock] = p;
+}
+
+void IOLoop::RemoveDelegateAsync(apr_socket_t *sock) {
+  apr_pollfd_t pfd = {mem_pool_, APR_POLL_SOCKET, 0, 0, {NULL}, NULL};
+  pfd.desc.s = sock;
+  apr_pollset_remove(pollset_, &pfd);
+
+  DelegatesType::iterator ite = delegates_.find(sock);
+  if (ite != delegates_.end()) {
+    ClientData *p = ite->second;
+    if (p) {
+      delete p;
+    }
+    delegates_.erase(ite);
+  }
+}
+
+}  // namespace livox

sdk_core/src/base/io_loop.h

@@ -0,0 +1,87 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_IO_LOOP_H_
+#define LIVOX_IO_LOOP_H_
+
+#include <boost/function.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/unordered_map.hpp>
+#include <utility>
+#include <vector>
+#include "apr_general.h"
+#include "apr_network_io.h"
+#include "apr_poll.h"
+#include "apr_thread_proc.h"
+#include "command_callback.h"
+#include "noncopyable.h"
+#include "thread_base.h"
+#include "util.h"
+
+namespace livox {
+
+class IOLoop : public noncopyable {
+ public:
+  class IOLoopDelegate {
+   public:
+    virtual void OnData(apr_socket_t *, void *) {}
+    virtual void OnTimer(apr_time_t) {}
+    virtual void OnWake() {}
+  };
+
+  typedef boost::function<void(void)> IOLoopTask;
+
+ public:
+  explicit IOLoop(apr_pool_t *mem_pool, bool enable_timer = true, bool enable_wake = true)
+      : pollset_(NULL), mem_pool_(mem_pool), last_timeout_(0), enable_timer_(enable_timer), enable_wake_(enable_wake){};
+
+  bool Init();
+  void Uninit();
+  void AddDelegate(apr_socket_t *sock, IOLoopDelegate *delegate, void *data = NULL);
+  void RemoveDelegate(apr_socket_t *sock, IOLoopDelegate *delegate);
+  void Loop();
+  bool Wakeup();
+  void PostTask(const IOLoopTask &task);
+
+ private:
+  void AddDelegateAsync(apr_socket_t *sock, IOLoopDelegate *delegate, void *data);
+  void RemoveDelegateAsync(apr_socket_t *sock);
+
+ private:
+  static const apr_uint32_t kMaxPollCount = 48;
+  typedef std::pair<IOLoopDelegate *, void *> ClientData;
+  typedef boost::unordered_map<apr_socket_t *, ClientData *> DelegatesType;
+  DelegatesType delegates_;
+  apr_pollset_t *pollset_;
+  apr_pool_t *mem_pool_;
+  apr_time_t last_timeout_;
+  boost::mutex mutex_;
+  bool enable_timer_;
+  bool enable_wake_;
+  std::vector<IOLoopTask> pending_tasks_;
+};
+
+}  // namespace livox
+
+#endif  // LIVOX_IO_LOOP_H_

sdk_core/src/base/io_thread.cpp

@@ -0,0 +1,60 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "io_thread.h"
+#include "apr_pools.h"
+
+namespace livox {
+
+void IOThread::Join() {
+  ThreadBase::Join();
+}
+
+void IOThread::ThreadFunc() {
+  if (loop_ == NULL) {
+    return;
+  }
+  while (!IsQuit()) {
+    loop_->Loop();
+  }
+}
+
+bool IOThread::Init(bool enable_timer, bool enable_wake) {
+  if (!ThreadBase::Init()) {
+    return false;
+  }
+
+  loop_.reset(new IOLoop(pool_, enable_timer, enable_wake));
+  return loop_->Init();
+}
+
+void IOThread::Uninit() {
+  if (loop_) {
+    loop_->Uninit();
+    loop_.reset(NULL);
+  }
+  ThreadBase::Uninit();
+}
+
+}  // namespace livox

sdk_core/src/base/io_thread.h

@@ -0,0 +1,47 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_IO_THREAD_H_
+#define LIVOX_IO_THREAD_H_
+#include <boost/smart_ptr.hpp>
+#include "io_loop.h"
+#include "thread_base.h"
+
+namespace livox {
+
+class IOThread : public ThreadBase {
+ public:
+  IOThread() : loop_(NULL) {}
+  bool Init(bool enable_timer = true, bool enable_wake = true);
+  void Join();
+  void Uninit();
+
+  IOLoop *loop() { return loop_.get(); }
+  void ThreadFunc();
+
+ private:
+  boost::scoped_ptr<IOLoop> loop_;
+};
+}  // namespace livox
+#endif  // LIVOX_IO_THREAD_H_

sdk_core/src/base/logging.h

@@ -0,0 +1,39 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_LOGGING_H_
+#define LIVOX_LOGGING_H_
+#include <iomanip>
+#include <iostream>
+
+#define __FILENAME__ (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__)
+
+#define LOG_TRACE std::cout << "TRACE " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+#define LOG_DEBUG std::cout << "DEBUG " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+#define LOG_INFO std::cout << "INFO " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+#define LOG_WARN std::cout << "WARN " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+#define LOG_ERROR std::cout << "ERROR " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+#define LOG_FATAL std::cout << "FATAL " << __FILENAME__ << ":" << __LINE__ << " " << __FUNCTION__ << " "
+
+#endif  // LIVOX_LOGGING_H_

sdk_core/src/base/network_util.cpp

@@ -0,0 +1,90 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "network_util.h"
+#include <ifaddrs.h>
+namespace livox {
+namespace util {
+apr_socket_t *CreateBindSocket(uint16_t port, apr_pool_t *mem_pool, bool nonblock) {
+  apr_sockaddr_t *sa = NULL;
+  apr_socket_t *s = NULL;
+  apr_status_t rv = APR_SUCCESS;
+
+  rv = apr_sockaddr_info_get(&sa, NULL, APR_INET, port, 0, mem_pool);
+  if (rv != APR_SUCCESS) {
+    return NULL;
+  }
+
+  rv = apr_socket_create(&s, sa->family, SOCK_DGRAM, APR_PROTO_UDP, mem_pool);
+  if (rv != APR_SUCCESS) {
+    return NULL;
+  }
+
+  rv = apr_socket_bind(s, sa);
+  if (rv != APR_SUCCESS) {
+    apr_socket_close(s);
+    s = NULL;
+    return NULL;
+  }
+
+  if (nonblock) {
+    apr_socket_opt_set(s, APR_SO_NONBLOCK, 1);
+    apr_socket_timeout_set(s, 0);
+  }
+  return s;
+}
+
+bool FindLocalIP(const struct sockaddr_in &client_addr, uint32_t &local_ip) {
+  struct ifaddrs *if_addrs = NULL, *addrs = NULL;
+  if (getifaddrs(&if_addrs) == -1) {
+    return false;
+  }
+  addrs = if_addrs;
+  bool found = false;
+  while (if_addrs != NULL) {
+    if ((if_addrs->ifa_addr != NULL) && (if_addrs->ifa_addr->sa_family == AF_INET))  // check it is IP4
+    {
+      // is a connected IP4 Address
+      struct sockaddr_in *ifu_localaddr = (struct sockaddr_in *)if_addrs->ifa_addr;
+      struct sockaddr_in *ifu_netmask = (struct sockaddr_in *)if_addrs->ifa_netmask;
+      if (ifu_localaddr->sin_addr.s_addr != htonl(INADDR_ANY)) {
+        if ((ifu_localaddr->sin_addr.s_addr & ifu_netmask->sin_addr.s_addr) ==
+            (client_addr.sin_addr.s_addr & ifu_netmask->sin_addr.s_addr)) {
+          local_ip = ifu_localaddr->sin_addr.s_addr;
+          found = true;
+          break;
+        }
+      }
+    }
+    if_addrs = if_addrs->ifa_next;
+  }
+
+  if (addrs) {
+    freeifaddrs(addrs);
+  }
+  return found;
+}
+
+}  // namespace util
+}  // namespace livox

sdk_core/src/base/network_util.h

@@ -0,0 +1,38 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_NETWORK_UTIL_H_
+#define LIVOX_NETWORK_UTIL_H_
+#include <apr_general.h>
+#include <apr_network_io.h>
+
+namespace livox {
+namespace util {
+
+apr_socket_t *CreateBindSocket(uint16_t port, apr_pool_t *mem_pool, bool nonblock = true);
+bool FindLocalIP(const struct sockaddr_in &client_addr, uint32_t &local_ip);
+
+}  // namespace util
+}  // namespace livox
+#endif  // LIVOX_NETWORK_UTIL_H_

sdk_core/src/base/noncopyable.h

@@ -0,0 +1,40 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_NONCOPYABLE_H_
+#define LIVOX_NONCOPYABLE_H_
+
+namespace livox {
+class noncopyable {
+ protected:
+  noncopyable() {}
+  ~noncopyable() {}
+
+ private:
+  noncopyable(const noncopyable &);
+  noncopyable &operator=(const noncopyable &);
+};
+
+}  // namespace livox
+#endif  // LIVOX_NONCOPYABLE_H_

sdk_core/src/base/thread_base.cpp

@@ -0,0 +1,71 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "thread_base.h"
+
+namespace livox {
+static void *APR_THREAD_FUNC ClassThreadHelperFunc(apr_thread_t *thd, void *data) {
+  ThreadBase *caller = static_cast<ThreadBase *>(data);
+  if (caller == NULL) {
+    return NULL;
+  }
+  caller->ThreadFunc();
+  apr_thread_exit(thd, APR_SUCCESS);
+  return NULL;
+}
+
+ThreadBase::ThreadBase() : thread_(NULL), quit_(false), pool_(NULL) {}
+
+bool ThreadBase::Start() {
+  quit_ = false;
+  apr_threadattr_t *thread_attr = NULL;
+  apr_status_t rv = APR_SUCCESS;
+  rv = apr_threadattr_create(&thread_attr, pool_);
+  if (rv != APR_SUCCESS) {
+    return false;
+  }
+  rv = apr_thread_create(&thread_, thread_attr, ClassThreadHelperFunc, this, pool_);
+  return rv == APR_SUCCESS;
+}
+
+void ThreadBase::Join() {
+  apr_status_t rv = APR_SUCCESS;
+  if (thread_) {
+    apr_thread_join(&rv, thread_);
+    thread_ = NULL;
+  }
+}
+
+bool ThreadBase::Init() {
+  return apr_pool_create(&pool_, NULL) == APR_SUCCESS;
+}
+
+void ThreadBase::Uninit() {
+  if (pool_) {
+    apr_pool_destroy(pool_);
+    pool_ = NULL;
+  }
+}
+
+}  // namespace livox

sdk_core/src/base/thread_base.h

@@ -0,0 +1,54 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_THREAD_BASE_H_
+#define LIVOX_THREAD_BASE_H_
+#include <apr_general.h>
+#include <apr_thread_proc.h>
+#include <boost/atomic/atomic.hpp>
+#include "noncopyable.h"
+
+namespace livox {
+
+class ThreadBase : public noncopyable {
+ public:
+  ThreadBase();
+  virtual ~ThreadBase() {}
+  virtual void ThreadFunc() = 0;
+  bool Init();
+  virtual void Uninit();
+  virtual bool Start();
+  virtual void Join();
+  void Quit() { quit_ = true; }
+  bool IsQuit() { return quit_; }
+
+ protected:
+  apr_thread_t *thread_;
+  boost::atomic_bool quit_;
+  apr_pool_t *pool_;
+};
+
+}  // namespace livox
+
+#endif  // LIVOX_THREAD_BASE_H_

sdk_core/src/base/util.cpp

@@ -0,0 +1,52 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "util.h"
+#include <stdio.h>
+#include <stdlib.h>
+using std::string;
+namespace livox {
+
+string PrintAPRStatus(apr_status_t s) {
+  char buf[128];
+  apr_strerror(s, buf, sizeof(buf));
+  return buf;
+}
+string PrintAPRTime(apr_time_t t) {
+  char cbuf[45 + 1];
+  apr_size_t sz = 45;
+  apr_time_exp_t xt;
+  apr_time_exp_gmt(&xt, t);
+  int milli = t % 1000;
+  apr_strftime(cbuf, &sz, 45, " %T.", &xt);
+  string s(cbuf);
+
+  char buffer[33];
+  sprintf(buffer, "%d", milli);
+
+  s += buffer;
+  return s;
+}
+
+}  // namespace livox

sdk_core/src/base/util.h

@@ -0,0 +1,37 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Livox. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#ifndef LIVOX_UTIL_H_
+#define LIVOX_UTIL_H_
+#include <string>
+#include "apr_general.h"
+#include "apr_time.h"
+
+namespace livox {
+
+std::string PrintAPRStatus(apr_status_t s);
+std::string PrintAPRTime(apr_time_t t);
+
+}  // namespace livox
+#endif  // LIVOX_UTIL_H_