jaus++/2.0/src/jaus/core/time/timeservice.cpp

Go to the documentation of this file.

#include "jaus/core/time/timeservice.h"
#include "jaus/core/events/event.h"
#include "jaus/core/time/querytime.h"
#include "jaus/core/time/reporttime.h"
#include "jaus/core/time/settime.h"
#include <iostream>
#include <ctime>

using namespace JAUS;

const std::string TimeService::Name = "urn:jaus:jss:core:Time";

TimeService::TimeService() : AccessControl::Child(Service::ID(TimeService::Name), Service::ID(AccessControl::Name))
{
    mpChangeTimeMethod = 0;
}


TimeService::~TimeService()
{
}


bool TimeService::GenerateEvent(const Events::Subscription& info) const
{
    if(info.mpQueryMessage->GetMessageCode() == QUERY_TIME)
    {
        ReportTime report;
        
        const QueryTime* query = dynamic_cast<const QueryTime *>(info.mpQueryMessage);

        if(query == NULL || query->IsFieldPresent(SetTime::PresenceVector::Time))
        {
            Time t;
            t.SetCurrentTime();
            report.SetTimeStamp(t);
        }
        if(query == NULL || query->IsFieldPresent(SetTime::PresenceVector::Date))
        {
            Date d;                
            // Get the current values.
            time_t rawtime;
            tm* ptm;
            time(&rawtime);
            ptm = gmtime(&rawtime);

            d.mYear = ptm->tm_year + 1900;
            d.mDay = ptm->tm_mday;
            d.mMonth = ptm->tm_mon;
            report.SetDateStamp(d);
        }

        SendEvent(info, &report);
        return true;
    }

    return false;
}


bool TimeService::IsEventSupported(const Events::Type type,
                                   const double requestedPeriodicRate,
                                   const Message* queryMessage,
                                   double& confirmedPeriodicRate,
                                   std::string& errorMessage) const
{
    // Support any type of event for REPORT_TIME data.
    if(queryMessage->GetMessageCode() == QUERY_TIME)
    {
        confirmedPeriodicRate = requestedPeriodicRate;
        return true;
    }
    return false;
}


void TimeService::Receive(const Message* message)
{
    switch(message->GetMessageCode())
    {
    case QUERY_TIME:
        {           
            const QueryTime* query = dynamic_cast<const QueryTime*>(message);
            if(query)
            {
                ReportTime report(message->GetSourceID(), GetComponentID());

                if(query->IsFieldPresent(SetTime::PresenceVector::Time))
                {
                    Time t;
                    t.SetCurrentTime();
                    report.SetTimeStamp(t);
                }
                if(query->IsFieldPresent(SetTime::PresenceVector::Date))
                {
                    Date d;                
                    // Get the current values.
                    time_t rawtime;
                    tm* ptm;
                    time(&rawtime);
                    ptm = gmtime(&rawtime);

                    d.mYear = ptm->tm_year + 1900;
                    d.mDay = ptm->tm_mday;
                    d.mMonth = ptm->tm_mon;
                    report.SetDateStamp(d);
                }

                Send(&report);
            }
        }
        break;
    case REPORT_TIME:
        {
            // Support needed if we are synchronizaing
            const ReportTime* report = dynamic_cast<const ReportTime*>(message);
            if(report && report->GetSourceID() == GetSynchronizeID())
            {
                Time t;
                Date d;
                
                // Get the current values.
                time_t rawtime;
                tm* ptm;
                time(&rawtime);
                ptm = gmtime(&rawtime);

                d.mYear = ptm->tm_year + 1900;
                d.mDay = ptm->tm_mday;
                d.mMonth = ptm->tm_mon;

                t.SetCurrentTime();

                if(report->IsFieldPresent(ReportTime::PresenceVector::Time))
                {
                    t = report->GetTimeStamp();
                }
                if(report->IsFieldPresent(ReportTime::PresenceVector::Date))
                {
                    d = report->GetDateStamp();
                }

                if(mpChangeTimeMethod)
                {
                    mpChangeTimeMethod(t, d);
                }
                else
                {
                    CxUtils::SetSystemTime(d.mYear,
                                           d.mMonth,
                                           t.mDay,
                                           t.mHour,
                                           t.mMinute,
                                           t.mSecond,
                                           t.mMilliseconds);
                }
                // Signal change in time.
                SignalEvent(REPORT_TIME);
            }
        }
        break;
    case SET_TIME:
        {
            const SetTime* command = dynamic_cast<const SetTime*>(message);
            if(command)
            {
                Time t;
                Date d;
                
                // Get the current values.
                time_t rawtime;
                tm* ptm;
                time(&rawtime);
                ptm = gmtime(&rawtime);

                d.mYear = ptm->tm_year + 1900;
                d.mDay = ptm->tm_mday;
                d.mMonth = ptm->tm_mon;

                t.SetCurrentTime();

                if(command->IsFieldPresent(SetTime::PresenceVector::Time))
                {
                    t = command->GetTimeStamp();
                }
                if(command->IsFieldPresent(SetTime::PresenceVector::Date))
                {
                    d = command->GetDateStamp();
                }

                if(mpChangeTimeMethod)
                {
                    mpChangeTimeMethod(t, d);
                }
                else
                {
                    CxUtils::SetSystemTime(d.mYear,
                                           d.mMonth,
                                           t.mDay,
                                           t.mHour,
                                           t.mMinute,
                                           t.mSecond,
                                           t.mMilliseconds);
                }
                // Signal change in time.
                SignalEvent(REPORT_TIME);
            }
        }
        break;
    default:
        break;
    }
}


Message* TimeService::CreateMessage(const UShort messageCode) const
{
    Message* message;
    switch(messageCode)
    {
    case QUERY_TIME:
        message = new QueryTime();
        break;
    case REPORT_TIME:
        message = new ReportTime();
        break;
    case SET_TIME:
        message = new SetTime();
        break;
    default:
        message = NULL;
        break;
    }
    return message;
}


void TimeService::CheckServiceSynchronization(const unsigned int timeSinceLastCheckMs)
{
    Address syncID = GetSynchronizeID();
    if(syncID.IsValid())
    {
        // See if we have an active subscription
        if(EventsService()->HaveSubscription(REPORT_TIME, syncID) == false)
        {
            QueryTime query(syncID, GetComponentID());
            query.SetPresenceVector(query.GetPresenceVectorMask());
            EventsService()->RequestEveryChangeEvent(syncID, &query);
        }
    }
}

/*  End of File */