radarFxConnectorDriver.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2025 MAK Technologies
 * All rights reserved.
 ******************************************************************************/
 
//! \file radarFxConnectorDriver.h
//! \brief Defines the driver for connecting to RadarFx external service
//! \ingroup sarClient
 
#pragma once
 
#include "vrePilotSarClient/sarClientPlugin.h"
 
#include <vrvCore/DtDriver.h>
 
#include <vreMessageManager/vreMessage.h>
 
class DtThread;
 
namespace makRadarFx
{
//! \brief Forward declaration of the RadarFx connector class
class DtRadarFxConnector;
 
//! \brief Forward declaration of the base message class for RadarFx
class DtBaseMessage;
} // namespace makRadarFx
 
namespace makVre
{
//! \brief Forward declaration of the VRE message class
class DtVreMessage;
} // namespace makVre
 
//! \brief Driver for managing the connection to the RadarFx service
//!
//! This driver is responsible for the DtRadarFxConnector object that connects to
//! the external RadarFx service for Synthetic Aperture Radar (SAR) image generation.
//! Because the connector blocks while attempting to connect, it runs in its own
//! worker thread. Connection status updates and SAR responses are pushed back to
//! the main thread for processing.
class DT_DLL_sarClient DtRadarFxConnectorDriver : public makVrv::DtDriver
{
public:
   //! \brief Constructor
   //! \param am Reference to the agent manager
   DtRadarFxConnectorDriver(makVrv::DtAgentManager& am);
 
   //! \brief Virtual destructor
   virtual ~DtRadarFxConnectorDriver() override;
 
   //! \brief Gets the class name of this driver
   //! \return Reference to the class name string
   virtual const std::string& className() const override;
 
   //! \brief Initializes the driver when it starts
   //! \return True if initialization was successful, false otherwise
   virtual bool onStart() override;
 
   //! \brief Cleans up resources when the driver stops
   //! \return True if cleanup was successful, false otherwise
   virtual bool onStop() override;
 
   //! \brief Performs per-frame updates
   //! \return True if the update was successful, false otherwise
   virtual bool onTick() override;
 
   //! \brief Handles SAR request messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Processes requests for Synthetic Aperture Radar images and forwards them to RadarFx
   virtual makVre::DtVreMessageResult handleSarRequest(makVre::DtVreMessage* msg);
 
   //! \brief Handles connection requests to RadarFx
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Processes requests to establish a connection to the RadarFx service
   virtual makVre::DtVreMessageResult handleConnectToRadarFx(makVre::DtVreMessage* msg);
 
   //! \brief Handles connection status change messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Processes notifications about changes in the connection status to RadarFx
   virtual makVre::DtVreMessageResult handleConnectionStatusChanged(makVre::DtVreMessage* msg);
 
   //! \brief Handles SAR response messages from RadarFx
   //! \param msg Pointer to the RadarFx message containing the response
   //!
   //! Function to be called by the delegate when a SAR response message is returned from RadarFx
   void handleSarResponse(makRadarFx::DtBaseMessage* msg);
 
   //! \brief Worker thread function for the RadarFx connector
   //! \param data Pointer to the driver instance
   //! \param stop Pointer to a flag indicating when to stop the thread
   //!
   //! Static function that runs in a separate thread to handle RadarFx connection operations
   static void driverWorkerFunction(void* data, volatile bool* stop);
 
protected:
   //! \brief Reference to the display element
   makVrv::DtDe& myDe;
 
   //! \brief Pointer to the RadarFx connector
   makRadarFx::DtRadarFxConnector* myConnector;
 
   //! \brief Pointer to the worker thread
   DtThread* myWorkerThread;
 
   //! \brief Flag indicating if the worker thread should exit
   bool myShouldQuit;
 
   //! \brief Current connection status to RadarFx
   bool myConnectionStatus;
 
   //! \brief Connection status as reported by the worker thread
   bool myWorkerThreadConnStatus;
};