#define MICRO 1000000
diagnostic_manager_t::diagnostic_manager_t()
- : initialized_{false}
+ : initialized_{false}, event_source_{nullptr}
{}
/// @brief Diagnostic manager isn't initialized at launch but after
{
// Make sure that socket has been opened.
if(! socket_)
- socket_.open(bus_);
+ socket_.open(get_bus_device_name());
struct utils::simple_bcm_msg bcm_msg;
memset(&bcm_msg.msg_head, 0, sizeof(bcm_msg.msg_head));
// Make sure that socket has been opened.
if(! tx_socket)
tx_socket.open(
- dm.get_can_bus());
+ dm.get_bus_device_name());
struct utils::simple_bcm_msg bcm_msg;
struct can_frame cfd;
vsnprintf(buffer, 256, format, args);
DEBUG(binder_interface, "%s: %s", __FUNCTION__, buffer);
+ va_end(args);
}
/// @brief The type signature for a... OpenXC TODO: not used yet.
void diagnostic_manager_t::shims_timer()
{}
-std::string diagnostic_manager_t::get_can_bus()
+const std::string diagnostic_manager_t::get_bus_name() const
{
return bus_;
}
+const std::string diagnostic_manager_t::get_bus_device_name() const
+{
+ return configuration_t::instance().get_can_bus_manager()
+ .get_can_device_name(bus_);
+}
+
active_diagnostic_request_t* diagnostic_manager_t::get_last_recurring_requests() const
{
return recurring_requests_.back();
return shims_;
}
+bool diagnostic_manager_t::socket_close()
+{
+ if(non_recurring_requests_.empty() && recurring_requests_.empty())
+ {
+ socket_.close();
+ return true;
+ }
+ return false;
+}
+
/// @brief Search for a specific active diagnostic request in the provided requests list
/// and erase it from the vector. This is useful at unsubscription to clean up the list otherwize
/// all received CAN messages will be passed to DiagnosticRequestHandle of all active diagnostic request
void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry)
{
entry->get_socket().close();
+ delete entry;
+ entry = nullptr;
}
/// @brief Cleanup a specific request if it isn't running and get complete. As it is almost
request_string, sizeof(request_string));
if(force && entry->get_recurring())
{
- find_and_erase(entry, recurring_requests_);
cancel_request(entry);
+ find_and_erase(entry, recurring_requests_);
DEBUG(binder_interface, "%s: Cancelling completed, recurring request: %s", __FUNCTION__, request_string);
}
- else
+ else if (!entry->get_recurring())
{
DEBUG(binder_interface, "%s: Cancelling completed, non-recurring request: %s", __FUNCTION__, request_string);
- find_and_erase(entry, non_recurring_requests_);
cancel_request(entry);
+ find_and_erase(entry, non_recurring_requests_);
}
+ socket_close();
}
}
void diagnostic_manager_t::cleanup_active_requests(bool force)
{
for(auto& entry : non_recurring_requests_)
+ {
if (entry != nullptr)
cleanup_request(entry, force);
+ }
for(auto& entry : recurring_requests_)
+ {
if (entry != nullptr)
cleanup_request(entry, force);
+ }
+
}
/// @brief Will return the active_diagnostic_request_t pointer for theDiagnosticRequest or nullptr if
if(entry != nullptr)
{
if(diagnostic_request_equals(&entry->get_handle()->request, request))
- {
- return entry;
- break;
- }
+ {return entry;}
}
}
return nullptr;
/// @return true if the request was added successfully. Returns false if there
/// wasn't a free active request entry, if the frequency was too high or if the
/// CAN acceptance filters could not be configured,
-active_diagnostic_request_t* diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name,
+active_diagnostic_request_t* diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string& name,
bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
const DiagnosticResponseCallback callback)
{