WBaseCommunication.h

#pragma once
#pragma make_public(BaseCommunication)
 
#include "WBaseSettings.h"
#include "BaseCommunication.h"
#include "WCommunicationStatus.h"
 
using namespace System::Threading;
using namespace System;
using namespace System::Runtime::InteropServices;
 
public delegate void ManagedDelegate(CommunicationStatus*);
 
public delegate void CommunicationEventHandler(System::Object^ sender, WUtils::WCommunicationStatus^ e);
 
namespace WBase {
 
    public ref class WBaseCommunication abstract
    {
    public:
 
        WBaseCommunication() {          
        }
 
        ~WBaseCommunication() {
        }
                
        virtual WUtils::WCommunicationStatus^ Connect() = 0;
 
        virtual void Disconnect() = 0;
                
        bool IsConnected() {
            return _communication->IsConnected();
        }
                
        // Properties
        property WBaseSettings^ Settings {
            WBaseSettings^ get() {
                return _settings;
            }
 
            void set(WBaseSettings^ pSettings) {
                _settings = pSettings;
            }
        }
 
        property BaseCommunication* __nativeCommunication {
            BaseCommunication* get() {
                return _communication;
            }
        }
 
        event CommunicationEventHandler^ CommunicationEvent {
            void add(CommunicationEventHandler^ handler) {
                if (!_callbackAssigned) {
                    IntPtr ptr = this->GetFunctionPointer();
                    MarshallingConnectionCheckerCallback nativeFunc = reinterpret_cast<MarshallingConnectionCheckerCallback>(ptr.ToPointer());
                    _communication->SetCommunicationCallback(nativeFunc);
                    _callbackAssigned = true;
                }
 
                _communicationEvent += handler;
            }
            void remove(CommunicationEventHandler^ handler) {
                _communicationEvent -= handler;
            }
        }
 
    protected:  
        ManagedDelegate^ del = gcnew ManagedDelegate(this, &WBaseCommunication::CommunicationCallback);
        IntPtr GetFunctionPointer() {           
            return Marshal::GetFunctionPointerForDelegate(del);
        }
            
        void CommunicationCallback(CommunicationStatus* status) {
            WUtils::WCommunicationStatus^ eventDataToFire = gcnew WUtils::WCommunicationStatus();
            for (int i = 0; i < status->Channels.size(); i++) {
                WUtils::WChannel^ toAdd = gcnew WUtils::WChannel();
                toAdd->RawDataAvailability = static_cast<DataAvailabilityEnum>(status->Channels[i].RawDataAvailability);
                toAdd->Type = static_cast<ChannelTypeEnum>(status->Channels[i].Type);
 
                eventDataToFire->Channels->Add(toAdd);
            }
 
            eventDataToFire->ErrorCode = gcnew WUtils::WCommunicationErrorCode();
            eventDataToFire->ErrorCode->ErrorCode = status->ErrorCode.ErrorCode;
            eventDataToFire->ErrorCode->ErrorMeaning = gcnew String(status->ErrorCode.ErrorMeaning.c_str());
 
            eventDataToFire->Status = static_cast<ConnectionStatusEnum>(status->Status);
                    
            _communicationEvent(this, eventDataToFire);
        }
 
        BaseCommunication* _communication;
        bool _monitoringExit = false;
 
    private:
        bool _callbackAssigned = false;
        event CommunicationEventHandler^ _communicationEvent;
        WBaseSettings^ _settings;
        Thread^ _monitoringWorker;
    };
}