eventengineunit.cpp

指纹门禁机管理系统

//---------------------------------------------------------------------------
#pragma hdrstop
#include "EventEngineUnit.h"
#include "DBAccessUnit.h"
//---------------------------------------------------------------------------
TEventEngine::TEventEngine()
{
  LogEventQueue.clear();
  DeviceCount = 0;
  ActiveDeviceCount = 0;
  for(int i=0;i<MAX_DEVICE_COUNT;i++)
  {
    DeviceTimerList[i].DiviceTimer = NULL;
    DeviceTimerList[i].DeviceHandle = 0;
    DeviceTimerList[i].DeviceID = 0;
    DeviceTimerList[i].MaxLogID = 0;
  }

  pDevice = GetDeviceAccessInstance();
  ActiveStatus = false;

  ErrCount = 0;
  IntiEngine();

}
//---------------------------------------------------------------------------

TEventEngine::~TEventEngine()
{
  LogEventQueue.clear();
  ActiveStatus = false;
  UnintiEngine();
}
//---------------------------------------------------------------------------

int TEventEngine::GetDeviceList()
{
   //从数据库得到设备配置列表
   TDBAccess aDBAccess;
   int lRV = aDBAccess.GetDeviceList(DeviceInfoQueue);
   DeviceCount = DeviceInfoQueue.size();
   return lRV;
}
//---------------------------------------------------------------------------
void __fastcall TEventEngine::OnTimer(TObject *Sender)
{
   TTimer* pThisTimer = (TTimer*)Sender;
   int lDeviceIndex = pThisTimer->Tag;

   int lDeviceHandle = DeviceTimerList[lDeviceIndex].DeviceHandle;
   if (lDeviceHandle > 0)
   {
      LogInfoBase_T aLogInfo;
      int lLogID = DeviceTimerList[lDeviceIndex].MaxLogID;
      int lRV = pDevice->GetLogInfo(lDeviceHandle,lLogID,aLogInfo);
      if (lRV == OK)
      {
         //加入到 事件消息队列
         aLogInfo.DeviceID = DeviceTimerList[lDeviceIndex].DeviceID;
         aLogInfo.DeviceLogID = lLogID;
         LogEventQueue.push_back(aLogInfo);
         DeviceTimerList[lDeviceIndex].MaxLogID = lLogID+1;  //当前日志号逐加
      }
      else
      {
         if (lRV != DevNoExist) //设备异常
         {
            ErrCount++;
            if(ErrCount > 1 && ErrCount < 30)
               return;
            if(ErrCount >= 30)
            {
               ErrCount = 0;
               return;
            }

            aLogInfo.DeviceID = DeviceTimerList[lDeviceIndex].DeviceID;
            aLogInfo.DeviceLogID = lLogID;
            aLogInfo.OpType = etDeviceError;
            TDateTime lCurTime = Now();
            DateTimeToSystemTime(lCurTime,aLogInfo.EventTime);
            LogEventQueue.push_back(aLogInfo);
            DeviceTimerList[lDeviceIndex].MaxLogID = lLogID;  //当前日志号逐加
         }
      }
   }

}
//---------------------------------------------------------------------------

int  TEventEngine::PushEventLog(LogInfoBase_T iLogInfo)
{
   LogEventQueue.push_back(iLogInfo);
   return OK;
}
//---------------------------------------------------------------------------
int TEventEngine::IntiEngine()
{
   int lRV = GetDeviceList();
   if (lRV == OK)
   {
      IterDeviceInfo_T IterDevice;
      DeviceInfo_T aDeviceInfo;
      ActiveDeviceCount = 0;
      int lDeviceIndex = 0;
      int lDeviceHandle;  //设备句柄
      for(IterDevice = DeviceInfoQueue.begin();IterDevice != DeviceInfoQueue.end();++IterDevice)
      {
         aDeviceInfo = *IterDevice;
         if (aDeviceInfo.DeviceStatus == dsRightStatus)  //正常在用
         {
            lDeviceHandle = pDevice->OpenDevice(aDeviceInfo.DeviceID,aDeviceInfo.DeviceType,aDeviceInfo.DeviceParams);
            if (lDeviceHandle != 0) //打开设备成功
            {
               DeviceTimerList[lDeviceIndex].DiviceTimer = new TTimer(NULL);
               DeviceTimerList[lDeviceIndex].DiviceTimer->Enabled = false;
               DeviceTimerList[lDeviceIndex].DiviceTimer->OnTimer = OnTimer;
               DeviceTimerList[lDeviceIndex].DiviceTimer->Interval = 2000;

               //把设备Index 赋值于TTimer的Tag
               DeviceTimerList[lDeviceIndex].DiviceTimer->Tag = lDeviceIndex;
               DeviceTimerList[lDeviceIndex].DeviceHandle = lDeviceHandle;
               DeviceTimerList[lDeviceIndex].DeviceID = aDeviceInfo.DeviceID;

               //得到当前设备最大的日志号
               int lMaxLogID = 0;
               pDevice->GetLogCount(lDeviceHandle,lMaxLogID);
               DeviceTimerList[lDeviceIndex].MaxLogID = lMaxLogID;
               lDeviceIndex++;

               aDeviceInfo.DeviceStatus = dsOpened;
               *IterDevice = aDeviceInfo;
            }
            else   //打开设备失败
            {
               LogInfoBase_T aLogInfo;
               aLogInfo.DeviceLogID = 0;
               aLogInfo.DeviceID = aDeviceInfo.DeviceID;
               aLogInfo.OpType = etOperateEvent;
               //写日志
            }
         }
         *IterDevice = aDeviceInfo;
      }
      ActiveDeviceCount = lDeviceIndex;

   }
   return lRV;

}
//---------------------------------------------------------------------------
int TEventEngine::UnintiEngine()
{
  for(int i=0;i<DeviceCount;i++)
  {
     if (DeviceTimerList[i].DiviceTimer)
     {
        delete DeviceTimerList[i].DiviceTimer;
        DeviceTimerList[i].DiviceTimer = NULL;
     }
     if (DeviceTimerList[i].DeviceHandle != 0)
     {
        //关闭设备
        pDevice->CloseDevice(DeviceTimerList[i].DeviceHandle);
        DeviceTimerList[i].DeviceHandle = 0;
     }
  }
  DeviceCount = 0;
  return OK;
}
//---------------------------------------------------------------------------

int TEventEngine::StartEngine()
{
   //启动引擎
   for(int i=0;i<DeviceCount;i++)
   {
      try
      {
        if (DeviceTimerList[i].DeviceHandle != 0)
        {
          int lIndex = DeviceTimerList[i].DiviceTimer->Tag;
          DeviceTimerList[lIndex].DiviceTimer->Enabled = true;
        }
      }
      catch(...)
      {
        return DeviceThreadError_E;
      }
   }
   ActiveStatus = true;
   return OK;

}
//---------------------------------------------------------------------------

int TEventEngine::StopEngine()
{
   //结束引擎
   for(int i=0;i<DeviceCount;i++)
   {
      try
      {
        if (DeviceTimerList[i].DeviceHandle != 0)
          DeviceTimerList[i].DiviceTimer->Enabled = false;
      }
      catch(...)
      {
        return DeviceThreadError_E;
      }
   }
   ActiveDeviceCount = 0;
   ActiveStatus = false;
   return OK;

}
//---------------------------------------------------------------------------
int TEventEngine::RestartEngine()
{
    //重启引擎
    StopEngine();
    UnintiEngine();
    IntiEngine();
    return StartEngine();
}
//---------------------------------------------------------------------------

int TEventEngine::StopDevice(int iDeviceID)
{
   //停止设备
   for(int i=0;i<DeviceCount;i++)
   {
      if (DeviceTimerList[i].DeviceID == iDeviceID)
      {
         try
         {
           DeviceTimerList[iDeviceID].DiviceTimer->Enabled = false;
         }
         catch(...)
         {
           return DeviceThreadError_E;
         }
         return OK;
      }
   }
   return NoDevice_E;

}
//---------------------------------------------------------------------------
int TEventEngine::StartDevice(int iDeviceID)
{
   //启用设备
   for(int i=0;i<DeviceCount;i++)
   {
      if (DeviceTimerList[i].DeviceID == iDeviceID)
      {
         try
         {
           DeviceTimerList[iDeviceID].DiviceTimer->Enabled = true;
         }
         catch(...)
         {
           return DeviceThreadError_E;
         }
         return OK;
      }
   }
   return NoDevice_E;

}
//---------------------------------------------------------------------------

bool TEventEngine::GetDeviceCount(int &oSumCount,int& oActiveCount)
{
  //得到设备数量
  oSumCount = DeviceCount;
  oActiveCount = ActiveDeviceCount;
  return true;
}
//---------------------------------------------------------------------------
bool TEventEngine::GetDeviceInfo(int iDeviceID,DeviceInfo_T* oDeviceInfo)
{
   //得到当前设备信息
   IterDeviceInfo_T IterDevice;
   DeviceInfo_T aDeviceInfo;
   for(IterDevice = DeviceInfoQueue.begin();IterDevice != DeviceInfoQueue.end();++IterDevice)
   {
      aDeviceInfo = *IterDevice;
      if (aDeviceInfo.DeviceID == iDeviceID)
      {
        *oDeviceInfo = aDeviceInfo;
        return true;
      }
   }
   return false;
}
//---------------------------------------------------------------------------
int  TEventEngine::GetDeviceHandle(int iDeviceID)
{
   //得到当前设备句柄及设备信息

   IterDeviceInfo_T IterDevice;
   DeviceInfo_T aDeviceInfo;
   int lHandle = 0;
   for(IterDevice = DeviceInfoQueue.begin();IterDevice != DeviceInfoQueue.end();++IterDevice)
   {
      aDeviceInfo = *IterDevice;
      if (aDeviceInfo.DeviceID == iDeviceID)
      {
         if (aDeviceInfo.DeviceStatus == dsOutStatus)  //设备状态为停用
         {
            lHandle = pDevice->OpenDevice(iDeviceID,aDeviceInfo.DeviceType,aDeviceInfo.DeviceParams);
         }
         else
         {
            //得到已打开设备的句柄
            for(int i=0;i<DeviceCount;i++)
            {
               if (DeviceTimerList[i].DeviceID == iDeviceID)
               {
                  lHandle = DeviceTimerList[i].DeviceHandle;
                  DeviceTimerList[i].DiviceTimer->Enabled = false;
                  return lHandle;
               }
            }
         }
      }
   }
   return lHandle;

}
//---------------------------------------------------------------------------
bool  TEventEngine::ReleaseDeviceHandle(int iDeviceID,int iDeviceHandle)
{

   IterDeviceInfo_T IterDevice;
   DeviceInfo_T aDeviceInfo;
   for(IterDevice = DeviceInfoQueue.begin();IterDevice != DeviceInfoQueue.end();++IterDevice)
   {
      aDeviceInfo = *IterDevice;
      if (aDeviceInfo.DeviceID == iDeviceID)
      {
        if (aDeviceInfo.DeviceStatus == dsOutStatus)  //设备状态为停用
        {
           pDevice->CloseDevice(iDeviceHandle);
           return true;
        }
        else
        {
           for(int i=0;i<DeviceCount;i++)
           {
              if (DeviceTimerList[i].DeviceID == iDeviceID)
              {
                 DeviceTimerList[i].DiviceTimer->Enabled = true;
                 return true;
              }
           }
        }
      }
   }
   return false;
}
//---------------------------------------------------------------------------

bool TEventEngine::IsExistDeviceInfo(int iDeviceID)
{
   //判断设备是否存在
   IterDeviceInfo_T IterDevice;
   DeviceInfo_T aDeviceInfo;
   for(IterDevice = DeviceInfoQueue.begin();IterDevice != DeviceInfoQueue.end();++IterDevice)
   {
      aDeviceInfo = *IterDevice;
      if (aDeviceInfo.DeviceID == iDeviceID)
      {
        return true;
      }
   }
   return false;
}
//---------------------------------------------------------------------------

int TEventEngine::PopEventLog(LogInfoBase_T& oLogInfo)
{
   //日志消息出队列
   if (LogEventQueue.empty())
      return LogQueueEmpty_E;
   IterLogInfoBase_T lter = LogEventQueue.begin();
   oLogInfo = *lter;
   if (LogEventQueue.size() > 0)
   {
     LogEventQueue.pop_front();
     return OK;
   }
   return LogQueueEmpty_E;
}
//---------------------------------------------------------------------------
bool TEventEngine::IsActive()
{
    //引擎是否启用
   return ActiveStatus;

}
//---------------------------------------------------------------------------

static TEventEngine* pEventEngine = NULL;

TEventEngine* GetEventEngineInstance()
{
   if (pEventEngine == NULL)
   {
      pEventEngine = new  TEventEngine();
   }
   return  pEventEngine;
}
//---------------------------------------------------------------------------
#pragma package(smart_init)