ATPPSPBridge Class Reference

Collaboration diagram for ATPPSPBridge:

Public Member Functions
bool	Connect (unsigned timeout, unsigned retryInterval)
void	Disconnect ()
bool	WaitATP ()
bool	ReleaseATP ()
void	SetProcessId (long pid)
SharedData &	GetSharedData () const
bool	IsConnected () const

Private Attributes
sem_t *	m_hATPReady = SEM_FAILED
sem_t *	m_hPSPReady = SEM_FAILED
int	m_hMapFile = -1
long	m_atpPid = 0
SharedData *	m_data = nullptr

Detailed Description

Definition at line 81 of file ATPPSPBridge.h.

Constructor & Destructor Documentation

ATPPSPBridge()

ATPPSPBridge::ATPPSPBridge

(

)

Definition at line 23 of file ATPPSPBridge.cpp.

{
}

~ATPPSPBridge()

ATPPSPBridge::~ATPPSPBridge

(

)

Definition at line 27 of file ATPPSPBridge.cpp.

{
    Disconnect();
}

Member Function Documentation

Connect()

bool ATPPSPBridge::Connect	(	unsigned	timeout,
		unsigned	retryInterval
	)

Definition at line 32 of file ATPPSPBridge.cpp.

{
    wxStopWatch sw;
    wxProgressDialog wait(_("Connecting"), _("Connecting to ATP, please wait."), timeout, nullptr, wxPD_AUTO_HIDE | wxPD_SMOOTH | wxPD_CAN_ABORT);
 
    while (true)
    {
        if (!wait.Update(sw.Time()))
            return false;
 
        Disconnect();
 
#ifdef _WIN32
 
        // ATP event
        m_hATPReady = OpenEventW(SYNCHRONIZE, FALSE, ATP_EVENT);
 
        if (m_hATPReady)
        {
            // PSP event
            m_hPSPReady = OpenEventW(EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, PSP_EVENT);
 
            if (m_hPSPReady)
            {
                // Shared memory
                m_hMapFile = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, SHM_NAME);
 
                if (m_hMapFile)
                {
                    m_data = static_cast<SharedData*>(MapViewOfFile(m_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 0));
 
                    if (m_data)
                        return true;
                }
            }
        }
 
#else
 
        // ATP semaphore
        m_hATPReady = sem_open(ATP_EVENT, 0);
 
        if (m_hATPReady != SEM_FAILED)
        {
            // PSP semaphore
            m_hPSPReady = sem_open(PSP_EVENT, 0);
 
            if (m_hPSPReady != SEM_FAILED)
            {
                // Shared memory
                m_hMapFile = shm_open(SHM_NAME, O_RDWR, 0);
                
                if (m_hMapFile >= 0)
                {
                    m_data = nullptr;
                    struct stat st;
                    if (fstat(m_hMapFile, &st) == 0)
                        m_data = static_cast<SharedData*>(mmap(nullptr, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_hMapFile, 0));
 
                    if (m_data != MAP_FAILED)
                        return true;
 
                    m_data = nullptr;
                }
            }
        }
 
#endif
 
        Disconnect();
 
        if (sw.Time() >= timeout)
            return false;
 
        wxMilliSleep(retryInterval);
        wxTheApp->Yield();
    }
}

Disconnect()

void ATPPSPBridge::Disconnect

(

)

Definition at line 111 of file ATPPSPBridge.cpp.

{
#ifdef _WIN32
 
    if (m_data) {
        UnmapViewOfFile(m_data);
        m_data = nullptr;
    }
 
    if (m_hMapFile) {
        CloseHandle(m_hMapFile);
        m_hMapFile = nullptr;
    }
 
    if (m_hATPReady) {
        CloseHandle(m_hATPReady);
        m_hATPReady = nullptr;
    }
 
    if (m_hPSPReady) {
        CloseHandle(m_hPSPReady);
        m_hPSPReady = nullptr;
    }
 
#else
 
    if (m_data) {
        struct stat st;
        if (m_hMapFile >= 0 && fstat(m_hMapFile, &st) == 0)
            munmap(m_data, st.st_size);
 
        m_data = nullptr;
    }
 
    if (m_hMapFile >= 0) {
        close(m_hMapFile);
        m_hMapFile = -1;
    }
 
    if (m_hATPReady != SEM_FAILED) {
        sem_close(m_hATPReady);
        m_hATPReady = SEM_FAILED;
    }
 
    if (m_hPSPReady != SEM_FAILED) {
        sem_close(m_hPSPReady);
        m_hPSPReady = SEM_FAILED;
    }
 
#endif
    m_atpPid = 0;
}

GetSharedData()

SharedData & ATPPSPBridge::GetSharedData

(

)

const

Definition at line 244 of file ATPPSPBridge.cpp.

{
    return *m_data;
}

IsConnected()

bool ATPPSPBridge::IsConnected

(

)

const

Definition at line 249 of file ATPPSPBridge.cpp.

{
    return m_data != nullptr;
}

ReleaseATP()

bool ATPPSPBridge::ReleaseATP

(

)

Definition at line 225 of file ATPPSPBridge.cpp.

{
#ifdef _WIN32
 
    if (!m_hPSPReady)
        return false;
 
    return SetEvent(m_hPSPReady) != FALSE;
 
#else
 
    if (m_hPSPReady == SEM_FAILED)
        return false;
 
    return sem_post(m_hPSPReady) == 0;
 
#endif
}

SetProcessId()

void ATPPSPBridge::SetProcessId ( long  pid )

inline

Definition at line 95 of file ATPPSPBridge.h.

{ m_atpPid = pid; }

WaitATP()

bool ATPPSPBridge::WaitATP

(

)

Definition at line 164 of file ATPPSPBridge.cpp.

{
#ifdef _WIN32
 
    if (!m_hATPReady)
        return false;
 
    while (true)
    {
        DWORD ret = WaitForSingleObject(m_hATPReady, 100);
 
        switch (ret)
        {
        case WAIT_OBJECT_0:
            // ATP signaled
            return true;
 
        case WAIT_TIMEOUT:
            // Check whether ATP is still running
            if (m_atpPid != 0 && !wxProcess::Exists(m_atpPid))
                return false;
            break;
 
        default:
            return false;
        }
    }
 
#else
 
    if (m_hATPReady == SEM_FAILED)
        return false;
 
    while (true)
    {
        timespec ts;
        if (clock_gettime(CLOCK_REALTIME, &ts) != 0)
            return false;
 
        ts.tv_nsec += 100000000; // 100 ms
 
        if (ts.tv_nsec >= 1000000000)
        {
            ts.tv_sec++;
            ts.tv_nsec -= 1000000000;
        }
 
        if (sem_timedwait(m_hATPReady, &ts) == 0)
            return true;
 
        if (errno != ETIMEDOUT)
            return false;
 
        // Check whether ATP is still running
        if (m_atpPid != 0 && !wxProcess::Exists(m_atpPid))
            return false;
    }
 
#endif
}

Member Data Documentation

m_atpPid

long ATPPSPBridge::m_atpPid = 0

private

Definition at line 113 of file ATPPSPBridge.h.

m_data

SharedData* ATPPSPBridge::m_data = nullptr

private

Definition at line 115 of file ATPPSPBridge.h.

m_hATPReady

sem_t* ATPPSPBridge::m_hATPReady = SEM_FAILED

private

Definition at line 108 of file ATPPSPBridge.h.

m_hMapFile

int ATPPSPBridge::m_hMapFile = -1

private

Definition at line 110 of file ATPPSPBridge.h.

m_hPSPReady

sem_t* ATPPSPBridge::m_hPSPReady = SEM_FAILED

private

Definition at line 109 of file ATPPSPBridge.h.

---

The documentation for this class was generated from the following files:

• Project/utils/ATPPSPBridge.h
• Project/utils/ATPPSPBridge.cpp