#include "stdafx.h"
|
#include "AlarmMonitor.h"
|
#include "Common.h"
|
#include "CBonder.h"
|
#include "Log.h"
|
#include "ToolUnits.h"
|
|
#define ALARM_MAX 200
|
|
CAlarmMonitor::CAlarmMonitor()
|
{
|
m_pRawData = new char[200];
|
memset(m_pRawData, 0, 200);
|
}
|
|
|
CAlarmMonitor::~CAlarmMonitor()
|
{
|
if (m_pRawData != nullptr) {
|
delete[] m_pRawData;
|
m_pRawData = nullptr;
|
}
|
|
for (auto item : m_mapAlarmTemplate) {
|
delete item.second;
|
}
|
m_mapAlarmTemplate.clear();
|
|
for (auto item : m_mapAlarming) {
|
item.second->release();
|
}
|
m_mapAlarming.clear();
|
|
for (auto item : m_alarms) {
|
item->release();
|
}
|
m_alarms.clear();
|
}
|
|
std::string& CAlarmMonitor::getClassName()
|
{
|
static std::string strClassName = "CAlarmMonitor";
|
return strClassName;
|
}
|
|
void CAlarmMonitor::onRecvBroadcast(void* pSender, CIntent* pIntent)
|
{
|
|
}
|
|
void CAlarmMonitor::onData(int id, const void* pData, int size)
|
{
|
const char* pszData = (const char*)pData;
|
if (MONITOR_ID_ALARM != id) {
|
return;
|
}
|
|
// ±È½ÏÓÐûÓб仯
|
if (compareData(m_pRawData, (const char*)pData, size)) {
|
return;
|
}
|
memcpy(m_pRawData, (const char*)pData, size);
|
|
|
// ÕÒµ½OnµÄ±¨¾¯²¢»º´æ
|
std::vector<int> alarmIds;
|
for (auto item : m_mapAlarmTemplate) {
|
if (isAlarmOn(item.first)) {
|
alarmIds.push_back(item.first);
|
}
|
}
|
|
|
// ·¢Éú¾¯¸æ£º
|
// ±È½ÏмӵÄONµÄ¾¯¸æ
|
// ¼´m_mapAlarmingÎÞ£¬alarmIdsÓÐ
|
for (auto item : alarmIds) {
|
if (m_mapAlarming.find(item) == m_mapAlarming.end()) {
|
auto iter = m_mapAlarmTemplate.find(item);
|
if (iter != m_mapAlarmTemplate.end()) {
|
CAlarm* pAlarm = new CAlarm(iter->second);
|
pAlarm->alarmOn();
|
pAlarm->addRef();
|
m_mapAlarming[item] = pAlarm;
|
LOGE("·¢ÉúÁ˾¯¸æ:%s", pAlarm->toString().c_str());
|
|
// ¾¯¸æÐÅÏ¢·¢³ö£¬ÒÔʹ½çÃæÏÔʾºÍÀúÊ·¼Ç¼±£´æ
|
SendBroadcast(&CIntent(BC_CODE_ALARM_ON, "", pAlarm));
|
}
|
}
|
}
|
|
// Ï÷³ý¾¯¸æ£º
|
// ±È½ÏµÃµ½ÔÀ´ON(m_mapAlarmingÓÐ), ÏÖÔÚOFFµÄ¾¯¸æ(alarmIdsÎÞ)
|
for (auto iter = m_mapAlarming.begin(); iter != m_mapAlarming.end();/* iter++*/) {
|
if (!findAlarm(alarmIds, iter->first)) {
|
// Ïû³ý¾¯¸æ, ͬʱ½«ÐÅÏ¢·¢³ö£¬ÒÔʹ½çÃæÏÔʾºÍÀúÊ·¼Ç¼±£´æ
|
CAlarm* pAlarm = iter->second;
|
pAlarm->alarmOff();
|
addAlarmToHistoryRecord(pAlarm);
|
m_mapAlarming.erase(iter++);
|
|
LOGE("Ïû³ýÁ˾¯¸æ:%s", pAlarm->toString().c_str());
|
SendBroadcast(&CIntent(BC_CODE_ALARM_OFF, "", pAlarm));
|
pAlarm->release();
|
}
|
else {
|
iter++;
|
}
|
}
|
}
|
|
int CAlarmMonitor::readAlarmListFromFile(const char* pszFilepath)
|
{
|
CStdioFile file;
|
if (!file.Open(pszFilepath, CFile::modeRead)) {
|
return -1;
|
}
|
|
CString strLine, strNumber, strLevel, strDescription;
|
int number, level;
|
while (file.ReadString(strLine)) {
|
if (!AfxExtractSubString(strNumber, (LPCTSTR)strLine, 0, ','))
|
continue;
|
if (!AfxExtractSubString(strLevel, (LPCTSTR)strLine, 1, ','))
|
continue;
|
if (!AfxExtractSubString(strDescription, (LPCTSTR)strLine, 2, ','))
|
continue;
|
|
try {
|
number = std::stoi((LPTSTR)(LPCTSTR)strNumber);
|
level = std::stoi((LPTSTR)(LPCTSTR)strLevel);
|
}
|
catch (...) {
|
continue;
|
}
|
|
addAlarmTemplate(number, level, (LPTSTR)(LPCTSTR)strDescription);
|
}
|
|
file.Close();
|
return (int)m_mapAlarmTemplate.size();
|
}
|
|
void CAlarmMonitor::init()
|
{
|
CComponent::init();
|
}
|
|
void CAlarmMonitor::term()
|
{
|
|
}
|
|
void CAlarmMonitor::OnTimer(UINT nTimerid)
|
{
|
|
}
|
|
const char* CAlarmMonitor::getAlarmText(int nID)
|
{
|
auto iter = m_mapAlarmTemplate.find(nID);
|
if (iter == m_mapAlarmTemplate.end()) return "";
|
return iter->second->getText().c_str();
|
}
|
|
void CAlarmMonitor::Serialize(CArchive& ar)
|
{
|
if (ar.IsStoring())
|
{
|
Lock();
|
int count = (int)m_alarms.size();
|
ar << count;
|
for (auto item : m_alarms) {
|
item->Serialize(ar);
|
}
|
Unlock();
|
}
|
else
|
{
|
Lock();
|
int count;
|
ar >> count;
|
for (int i = 0; i < count; i++) {
|
CAlarm* pAlarm = new CAlarm();
|
pAlarm->Serialize(ar);
|
addAlarmToHistoryRecord(pAlarm);
|
LOGE("ÀúÊ·¾¯¸æ:%s", pAlarm->toString().c_str());
|
}
|
Unlock();
|
}
|
}
|
|
std::map<int, CAlarm*>& CAlarmMonitor::getAlarmingMap()
|
{
|
return m_mapAlarming;
|
}
|
|
BOOL CAlarmMonitor::isAlarming()
|
{
|
Lock();
|
BOOL bAlarming = !m_mapAlarming.empty();
|
Unlock();
|
return bAlarming;
|
}
|
|
CAlarm* CAlarmMonitor::getActiveAlarm()
|
{
|
Lock();
|
if (m_mapAlarming.empty()) {
|
Unlock();
|
return nullptr;
|
}
|
auto iter = m_mapAlarming.begin();
|
Unlock();
|
|
return iter->second;
|
}
|
|
std::list< CAlarm*>& CAlarmMonitor::getAlarmRecords()
|
{
|
return m_alarms;
|
}
|
|
void CAlarmMonitor::getAlarmRecords(std::list< CAlarm*>& list)
|
{
|
Lock();
|
list = m_alarms;
|
Unlock();
|
}
|
|
BOOL CAlarmMonitor::compareData(const char* pScrData, const char* pTarData, int len)
|
{
|
for (int i = 0; i < len; i++) {
|
if (pScrData[i] != pTarData[i]) {
|
return FALSE;
|
}
|
}
|
|
return TRUE;
|
}
|
|
int CAlarmMonitor::addAlarmTemplate(int id, int level, const char* pszDescription)
|
{
|
auto iter = m_mapAlarmTemplate.find(id);
|
if (iter != m_mapAlarmTemplate.end()) return -1;
|
|
CAlarm* pAlarm = new CAlarm(id, level, pszDescription);
|
m_mapAlarmTemplate[id] = pAlarm;
|
return 0;
|
}
|
|
BOOL CAlarmMonitor::isAlarmOn(int id)
|
{
|
int byteIndex, bitIndex;
|
byteIndex = (id - 1) / 8;
|
bitIndex = (id - 1) % 8;
|
|
return CToolUnits::getBit(m_pRawData[byteIndex], bitIndex);
|
}
|
|
BOOL CAlarmMonitor::findAlarm(std::vector<int>& ids, int id)
|
{
|
for (auto item : ids) {
|
if (item == id) return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
void CAlarmMonitor::addAlarmToHistoryRecord(CAlarm* pAlarm)
|
{
|
pAlarm->addRef();
|
m_alarms.push_back(pAlarm);
|
if (m_alarms.size() > 1000) {
|
CAlarm* pTemp = m_alarms.front();
|
pTemp->release();
|
m_alarms.pop_front();
|
}
|
}
|
