void setGerror(uwb_error_e error_code, GError **error);
private:
- const std::string _uwb_quark_str =
- std::string("uwb-manager-error-quark");
- const std::string _invalid_parameter_str =
- std::string("org.tizen.uwb.Error.InvalidParameter");
- const std::string _out_of_memory_str =
- std::string("org.tizen.uwb.Error.OutOfMemory");
- const std::string _permission_denied_str =
- std::string("org.tizen.uwb.Error.NotPermitted");
- const std::string _operation_failed_str =
- std::string("org.tizen.uwb.Error.OperationFailed");
+ const std::string _uwb_quark_str{"uwb-manager-error-quark"};
+ const std::string _invalid_parameter_str{"org.tizen.uwb.Error.InvalidParameter"};
+ const std::string _out_of_memory_str{"org.tizen.uwb.Error.OutOfMemory"};
+ const std::string _permission_denied_str{"org.tizen.uwb.Error.NotPermitted"};
+ const std::string _operation_failed_str{"org.tizen.uwb.Error.OperationFailed"};
};
}
#include <list>
#include <map>
#include <memory>
+#include <chrono>
#include <UwbMqttRequest.h>
/* Warning: getMqttContext should be used only for test purpose */
MqttContext *getMqttContextPtr() {return _mqtt_context.get();};
- static constexpr int _position_broadcast_interval = 1;
- static constexpr int _default_mqtt_qos = 1;
- static constexpr int _default_remove_duration = 10;
- static constexpr int _default_tizen_uwb_broadcast_topic_len = 21;
- static constexpr int _default_tizen_uwb_broadcast_payload_len = 16;
+ static constexpr int _default_mqtt_qos{1};
+ static constexpr int _default_tizen_uwb_broadcast_topic_len{21};
+ static constexpr int _default_tizen_uwb_broadcast_payload_len{16};
+ static constexpr std::chrono::milliseconds _position_broadcast_interval{1000};
+ static constexpr std::chrono::milliseconds _default_remove_duration{10000};
private:
int tryConnect(void);
+++ /dev/null
-/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __METHOD_HANDLER_H__
-#define __METHOD_HANDLER_H__
-
-#include <string>
-
-#include <gio/gio.h>
-
-#include "generated-code.h"
-
-#include <uwb-error-def.h>
-
-namespace UwbManagerNamespace {
-
-class MethodHandler {
-
-public:
- virtual ~MethodHandler() {};
- virtual void registerHandler(UwbGdbuslibManager *manager_skeleton) = 0;
- virtual UwbManager *getManager() = 0;
-};
-
-}
-
-#endif /* __METHOD_HANDLER_H__ */
#include <stdbool.h>
#include <list>
+#include <chrono>
#include "MQTTAsync.h"
#include "UwbMqttRequest.h"
int unsubscribe(std::unique_ptr<UwbMqttRequest> request);
int publish(std::unique_ptr<UwbMqttRequest> request);
private:
- static constexpr int _mqtt_connect_timeout = 2;
- static constexpr int _connection_retry_timeout = 5;
+ static constexpr std::chrono::milliseconds _mqtt_connect_timeout{2000};
+ static constexpr std::chrono::milliseconds _connection_retry_timeout{5000};
guint _retry_connect_source;
MQTTAsync _mqtt_client;
std::function<void(bool)> _connection_state_cb;
#ifndef __NODE_H__
#define __NODE_H__
+#include <chrono>
+
//#include <uwb-log-def.h>
#include <uwb-hpi.h>
class Node {
public:
Node(): _distance(0), _pan_id(0), _node_id(0), _x(0), _y(0), _z(0),
- _is_remote(false), _is_calculated(false), _tech(TECH_UNKNOWN), _last_update(0) {};
+ _is_remote(false), _is_calculated(false), _tech(TECH_UNKNOWN),
+ _last_update(std::chrono::steady_clock::now()) {};
Node(int pan_id, unsigned long long node_id, int x, int y, int z) :
_distance(0), _pan_id(pan_id), _node_id(node_id), _x(x), _y(y), _z(z),
- _is_remote(false), _is_calculated(false), _tech(TECH_UNKNOWN), _last_update(0) {};
+ _is_remote(false), _is_calculated(false), _tech(TECH_UNKNOWN),
+ _last_update(std::chrono::steady_clock::now()) {};
Node(unsigned long long distance, int pan_id, unsigned long long node_id,
int x, int y, int z, bool is_remote, bool is_calculated, int tech) :
_distance(distance), _pan_id(pan_id), _node_id(node_id),
_x(x), _y(y), _z(z), _is_remote(is_remote), _is_calculated(is_calculated),
- _tech(tech), _last_update(0) {};
+ _tech(tech), _last_update(std::chrono::steady_clock::now()) {};
Node(uwb_hpi_node_s *node) :
_distance(node->distance), _pan_id(node->pan_id), _node_id(node->node_id),
_x(node->x), _y(node->y), _z(node->z), _is_remote(node->is_remote),
- _is_calculated(false), _tech(TECH_UWB), _last_update(0){};
- Node(const Node &node) {
- _distance = node._distance;
- _pan_id = node._pan_id;
- _node_id = node._node_id;
- _x = node._x;
- _y = node._y;
- _z = node._z;
- _is_remote = node._is_remote;
- _is_calculated = node._is_calculated;
- _tech = node._tech;
- _last_update = node._last_update;
- }
+ _is_calculated(false), _tech(TECH_UWB),
+ _last_update(std::chrono::steady_clock::now()){};
Node(const Node *node) {
_distance = node->_distance;
_pan_id = node->_pan_id;
_last_update = node->_last_update;
}
- //~Node(){UWB_LOGI("%lld removed", _last_update);}
+ //~Node(){UWB_LOGI("%llu removed", _node_id);}
+ Node(const Node &node) = default;
+ Node& operator=(const Node&) = default;
+ Node(Node&&) = default;
+ Node& operator=(Node&&) = default;
+
void setDistance(unsigned long long distance) {_distance = distance;};
unsigned long long getDistance() {return _distance;};
void setPanId(int id) {_pan_id = id;};
void setIsCalculated(bool is_calculated) {_is_calculated = is_calculated;};
bool getTech(void) {return _tech;};
void setTech(int tech) {_tech = tech;};
- uint64_t getLastUpdate(void) {return _last_update;};
- void setLastUpdate(uint64_t update_time) {_last_update = update_time;};
+ std::chrono::steady_clock::time_point getLastUpdate(void) {return _last_update;};
+ void setLastUpdate(std::chrono::steady_clock::time_point update_time) {_last_update = update_time;};
bool hasSamePosition(Node *node) {return (_x == node->_x && _y == node->_y && _z == node->_z);};
private:
unsigned long long _distance;
bool _is_remote;
bool _is_calculated;
int _tech;
- uint64_t _last_update;
+ std::chrono::steady_clock::time_point _last_update;
};
}
UwbConfig(std::shared_ptr<UwbRangePlugin> range_plugin) :
_configurations(nullptr), _range_plugin(range_plugin) {};
- UwbConfig(const UwbConfig& config);
~UwbConfig();
+ UwbConfig(const UwbConfig& config);
+ UwbConfig& operator=(const UwbConfig& config);
+ UwbConfig(UwbConfig&& config) = default;
+ UwbConfig& operator=(UwbConfig&& config) = default;
int loadConfiguration(void);
int setConfigurations(GVariant *configurations);
_set_position(nullptr),
_send_message(nullptr),
_send_message_to(nullptr) {};
- ~UwbDbusIfaceAdapter();
void setTest(std::function<int (void)> test)
{_test = test;};
void init(GDBusConnection *connection, UwbGdbuslibManager *manager_skeleton);
void deinit(void);
private:
- const std::string _uwb_dbus_path_str =
- std::string("/org/tizen/uwb/manager");
+ const std::string _uwb_dbus_path_str{"/org/tizen/uwb/manager"};
std::function<int (void)> _test;
std::function<int (void)> _reset;
std::function<int (void)> _factory_reset;
public:
UwbDbusManager() : _owner_id(0), _manager_skeleton(nullptr), _bus_acquired_cb(nullptr) {};
~UwbDbusManager();
+ UwbDbusManager(const UwbDbusManager &) = default;
+ UwbDbusManager& operator=(const UwbDbusManager&) = default;
+ UwbDbusManager(UwbDbusManager&&) = default;
+ UwbDbusManager& operator=(UwbDbusManager&&) = default;
void setBusAcquiredCallback(std::function<void(GDBusConnection *, UwbGdbuslibManager *)> bus_acquired_cb)
{_bus_acquired_cb = bus_acquired_cb;};
void emitNodeRemovedSignal(Node *p_node);
UwbGdbuslibManager *getManagerSkeleton(void) {return _manager_skeleton;};
private:
- const std::string uwb_dbus_service_str =
- std::string("org.tizen.uwb");
+ const std::string uwb_dbus_service_str{"org.tizen.uwb"};
guint _owner_id;
/* Add interface to default object path */
class UwbMqttMessage {
public:
UwbMqttMessage();
- ~UwbMqttMessage();
UwbMqttMessage(Node &node_info);
+
std::string &getTopic(void);
std::string &getPayload(void);
private:
UwbMqttRequest(void);
UwbMqttRequest(int qos, std::unique_ptr<UwbMqttMessage> mqtt_msg);
UwbMqttRequest(int qos, int retained, std::unique_ptr<UwbMqttMessage> mqtt_msg);
+
int getQos(void) {return _qos;};
int getRetained(void) {return _retained;};
std::string &getTopic(void) {return _mqtt_msg->getTopic();};
_is_enable(false), _pan_id(0), _range_plugin(nullptr){};
UwbNetwork(std::shared_ptr<UwbRangePlugin> range_plugin) :
_is_enable(false), _pan_id(0), _range_plugin(range_plugin){};
- ~UwbNetwork();
+
void setPanId(int pan_id) {_pan_id = pan_id;};
int getPanId(void) {return _pan_id;};
bool is_enable(void) {return _is_enable;};
class UwbPluginManager {
public:
+ UwbPluginManager() {};
~UwbPluginManager();
+ UwbPluginManager(const UwbPluginManager &) = default;
+ UwbPluginManager& operator=(const UwbPluginManager&) = default;
+ UwbPluginManager(UwbPluginManager&&) = default;
+ UwbPluginManager& operator=(UwbPluginManager&&) = default;
+
int load(std::shared_ptr<UwbPlugin> plugin);
int unload(std::shared_ptr<UwbPlugin> plugin);
private:
std::map <std::shared_ptr<UwbPlugin>, void *>_plugins;
- const std::string _func_tbl_symbol = std::string("uwb_plugin_load");
+ const std::string _func_tbl_symbol{"uwb_plugin_load"};
};
}
public:
UwbPosition(std::shared_ptr<UwbRangePlugin> range_plugin) :
_range_plugin(range_plugin){};
- ~UwbPosition();
int update(void);
Name: uwb-manager
Summary: This is the daemon managing UWB related functionalities
-Version: 0.0.2
+Version: 0.0.3
Release: 1
Group: Network & Connectivity/Wireless
License: Apache-2.0
#include <unistd.h>
#include <sys/types.h>
#include <algorithm>
-#include <chrono>
#include <uwb-log-def.h>
this->_node_removed_cb = nullptr;
}
-static uint64_t __get_current_miliseconds()
-{
- return std::chrono::duration_cast<std::chrono::milliseconds>\
- (std::chrono::high_resolution_clock::now().time_since_epoch()).count();
-}
-
void LocationManager::extractNodeInfo(char *topic, unsigned char *payload, Node *node)
{
std::string node_id_str = std::string(topic).substr(
node->setX(x);
node->setY(y);
node->setZ(z);
- node->setLastUpdate(__get_current_miliseconds());
+ node->setLastUpdate(std::chrono::steady_clock::now());
}
static bool __is_mqtt_message_vaild(char *topic, int topic_len,
bool added = itr == this->_node_map.end();
if (added) {
- if (this->_node_added_cb != nullptr)
+ if (this->_node_added_cb)
this->_node_added_cb(node_info.get());
} else {
- if (this->_node_updated_cb != nullptr)
+ if (this->_node_updated_cb)
this->_node_updated_cb(node_info.get());
}
int LocationManager::startPublishPosition(void)
{
this->_position_broadcast_source =
- g_timeout_add(LocationManager::_position_broadcast_interval * 1000,
+ g_timeout_add(LocationManager::_position_broadcast_interval.count(),
__broadcast_position,
(gpointer)this);
return 0;
void LocationManager::updateOwnUwbPosition(void)
{
this->_current = this->_uwb_position->getOwnNode();
- if (this->_position_updated_cb != nullptr)
+ if (this->_position_updated_cb)
this->_position_updated_cb(&(this->_current));
}
auto itr = this->_node_map.find(p_node->getNodeId());
bool added = itr == this->_node_map.end();
- p_node->setLastUpdate(__get_current_miliseconds());
+ p_node->setLastUpdate(std::chrono::steady_clock::now());
this->_node_map[p_node->getNodeId()] =
std::unique_ptr<Node>((Node *)new Node(p_node));
if (added) {
- if (this->_node_added_cb != nullptr)
+ if (this->_node_added_cb)
this->_node_added_cb(p_node);
} else {
- if (this->_node_updated_cb != nullptr)
+ if (this->_node_updated_cb)
this->_node_updated_cb(p_node);
}
}
void LocationManager::removeOutdatedUwbNodes(void)
{
- uint64_t current_mil = __get_current_miliseconds();
+ auto current_mil = std::chrono::steady_clock::now();
/* remove node which is not found during
- *LocationManager::_default_remove_duration * 1000 miliseconds
+ *LocationManager::_default_remove_duration miliseconds
*/
for (auto itr = this->_node_map.begin(); itr != this->_node_map.end();) {
Node *node_ptr = itr->second.get();
- if (current_mil - node_ptr->getLastUpdate()
- > LocationManager::_default_remove_duration * 1000) {
- if (this->_node_removed_cb != nullptr)
+ if (std::chrono::duration_cast<std::chrono::milliseconds>(current_mil - node_ptr->getLastUpdate()).count()
+ > LocationManager::_default_remove_duration.count()) {
+ if (this->_node_removed_cb)
this->_node_removed_cb(node_ptr);
itr = this->_node_map.erase(itr);
} else
{
__UWB_LOG_FUNC_ENTER__;
- retv_if(this->_mqtt_client != nullptr, -1);
+ retv_if(this->_mqtt_client, -1);
UWB_LOGI("Connect to %s:tcp %d", server, port);
__message_arrived, nullptr);
__UWB_LOG_FUNC_EXIT__;
- return this->_mqtt_client != nullptr ? 0 : -1;
+ return this->_mqtt_client ? 0 : -1;
}
int MqttContext::destroyMqttClient(void)
}
this->_retry_connect_source =
- g_timeout_add(MqttContext::_connection_retry_timeout * 1000,
+ g_timeout_add(MqttContext::_connection_retry_timeout.count(),
__retry_connect,
(gpointer)this);
}
opts.keepAliveInterval = 20;
- opts.connectTimeout = this->_mqtt_connect_timeout;
+ opts.connectTimeout = this->_mqtt_connect_timeout.count();
opts.cleansession = 1;
opts.onSuccess = __connect_on_success_cb;
opts.onFailure = __connect_on_failure_cb;
#define CONFIGFILE tzplatform_mkpath(TZ_SYS_RO_ETC, "/uwb/uwb-plugin.conf")
-
-UwbConfig::UwbConfig(const UwbConfig& config)
-{
- this->_configurations = g_variant_ref(config._configurations);
-}
-
UwbConfig::~UwbConfig()
{
__UWB_LOG_FUNC_ENTER__;
__UWB_LOG_FUNC_EXIT__;
}
+UwbConfig::UwbConfig(const UwbConfig& config)
+{
+ this->_range_plugin = config._range_plugin;
+ this->_configurations = g_variant_ref(config._configurations);
+}
+
+UwbConfig& UwbConfig::operator=(const UwbConfig& config)
+{
+ this->_range_plugin = config._range_plugin;
+ this->_configurations = g_variant_ref(config._configurations);
+
+ return *this;
+}
+
int UwbConfig::loadConfiguration(void)
{
JsonParser *parser = NULL;
g_variant_unref(this->_configurations);
this->_configurations = configuration;
- if (this->_range_plugin != nullptr)
+ if (this->_range_plugin)
this->_range_plugin->setConfigurations(0, configuration);
g_object_unref(parser);
g_free(parameters_debug_str);\
} while (0)
-UwbDbusIfaceAdapter::~UwbDbusIfaceAdapter()
-{
-}
-
static void __dbus_return_err(uwb_error_e ret, GDBusMethodInvocation *invocation)
{
GdbusError gdbus_error;
{"handle-set-position", (void *)__handle_set_position},
{"handle-send-message", (void *)__handle_send_message},
- {"handle-send-message-to", (void *)__handle_send_message_to},
- {NULL, NULL}
+ {"handle-send-message-to", (void *)__handle_send_message_to}
};
void UwbDbusIfaceAdapter::init(GDBusConnection *connection,
__UWB_LOG_FUNC_ENTER__;
/* Register method callbacks as signal callback */
- for (int i = 0; handlers[i].method_name != NULL; ++i)
+ for (const auto &handler : handlers)
g_signal_connect(
manager_skeleton,
- handlers[i].method_name,
- G_CALLBACK(handlers[i].handler),
+ handler.method_name,
+ G_CALLBACK(handler.handler),
gpointer(this));
/* Set connection to 'manager' */
using namespace UwbManagerNamespace;
-UwbMqttMessage::~UwbMqttMessage()
-{
- __UWB_LOG_FUNC_ENTER__;
-
- __UWB_LOG_FUNC_EXIT__;
-}
-
UwbMqttMessage::UwbMqttMessage()
{
this->_topic = this->_broadcast_position_topic_prefix + std::string("+");
using namespace UwbManagerNamespace;
-UwbNetwork::~UwbNetwork()
-{
- __UWB_LOG_FUNC_ENTER__;
-
- __UWB_LOG_FUNC_EXIT__;
- return;
-}
-
static void __destroy_node(gpointer data)
{
if (data != NULL) {
using namespace UwbManagerNamespace;
-UwbPosition::~UwbPosition()
-{
- __UWB_LOG_FUNC_ENTER__;
-
- _node_list.clear();
-
- __UWB_LOG_FUNC_EXIT__;
- return;
-}
-
int UwbPosition::updateUwbOwnNode()
{
if (this->_range_plugin == nullptr)
static void __run_main_loop(void)
{
- if (main_loop != nullptr)
+ if (main_loop)
return;
main_loop = g_main_loop_new(nullptr, FALSE);
projects / platform / core / connectivity / uwb-manager.git / commitdiff