server/websocket/wsTimerThread.cpp

#include "wsTimerThread.h"
#include <iostream>
#include "wsClientMgr.h"
#include "constdef.h"
#include "log.h"
#include "sys_setting.h"
#include "module_service/module_screen.h"

namespace sys
{
	wsTimerThread::wsTimerThread()
	{
		__Reset();
	}

	wsTimerThread::~wsTimerThread()
	{
		Stop();
	}

	void wsTimerThread::Start()
	{
		__Running = true;
		__Thread.reset( new boost::thread( boost::bind( &wsTimerThread::_ThreadFunc, this, this ) ) );
        //__Thread->detach();
	}

	void wsTimerThread::Stop()
	{
        if(__Thread==nullptr)
        {
            return;
        }
        __Thread->interrupt();
        __Running = false;
		std::cout << "wsTimerThread::Stop() begin" << std::endl;

		__Enable = false;

		if ( __Running )
		{
			boost::unique_lock<boost::mutex> lock( __ExitMutex );
			__ExitCond.wait( lock );
		}

		__Reset();
        __Thread=nullptr;

		std::cout << "wsTimerThread::Stop() end" << std::endl;
	}

	void wsTimerThread::__Reset()
	{
		__Enable  = true;
		__Running = false;
	}

	void wsTimerThread::__ChkConfig()
	{
		if ( __Config.SendInterval < MIN_SEND_INTERVAL )
		{
			__Config.SendInterval = MIN_SEND_INTERVAL;
		}
	}

	void wsTimerThread::__SendCardPos()
	{
        // 大屏只显示人卡相关数据
        std::map<uint64_t, _CARD_POS_> cpl;
        __CardPosList.copy(cpl);
        for(auto it = cpl.begin();it != cpl.end();){
            if(1 == it->second.Type){
                cpl.insert(std::make_pair(it->first, it->second));
                it++;
            }else{
                cpl.erase(it++);
            }
        }
        // 大屏相关数据业务处理
        if(cpl.size() > 0){
            module_screen::instance()->do_write(cpl);
        }
        
        // 人车数据发送给web端
        std::map<uint64_t, _CARD_POS_> CardPosList;
		if(__CardPosList.empty())
		    return;
        __CardPosList.copy( CardPosList );
     
        std::string jsCardPos = __jsBuilder.BuildCardPos(CardPosList);

        if(jsCardPos == ""){
            return;
        }

		swsClientMgr.send( JSON_CMD_VALUE_PUSH, jsCardPos );
	}

    void wsTimerThread::send_card_pos()
    {
        if(__CardPosList.empty()){
            return;
        } 

        std::map<uint64_t, _CARD_POS_> cards;
        __CardPosList.copy(cards);
        //service_position send
        for(auto it = cards.begin(); it != cards.end(); ++it)
        {
            std::string json_pos = __jsBuilder.build_ios_card_pos(it->second);
            //log_info("[service-position] json_pos: card_id=%d, freq=%.2f, json=%s", it->second.ID, it->second.m_freq, json_pos.c_str());
            ios_service::m_ios_service->notify(json_pos, std::to_string(it->second.ID), it->second.m_freq);
        }
    }

    void wsTimerThread::temp_send_card_pos()
    {
        if(__CardPosList.empty()){
            return;
        }
        std::map<uint64_t, _CARD_POS_> cards;
        __CardPosList.copy(cards);
        std::string json_pos = __jsBuilder.build_tmp_card_pos(cards);
        swsClientMgr.send(JSON_CMD_VALUE_PUSH, json_pos);
    }

    void wsTimerThread::send_light_state()
    {
        if(light_state_list.empty()){
            return;
        }
        std::vector<light_state> lights = light_state_list;
        //log_info("[light_info] light_state's size=%d, copy=%d", light_state_list.size(), lights.size());
        std::string json_light = __jsBuilder.build_traffic_light(lights);
        swsClientMgr.send(JSON_CMD_VALUE_PUSH, json_light);
        light_state_list.clear();
		light_state_list.resize(0);
    }

	void wsTimerThread::send_device_state()
	{
		if(device_state_list.empty()){
			return;
		}

		std::vector<device_state> ds = device_state_list;
		std::string json_device = __jsBuilder.build_device_state(ds);
		swsClientMgr.send(JSON_CMD_VALUE_PUSH, json_device);
		//device_state_list.erase(device_state_list.begin(), device_state_list.end());
		device_state_list.clear();
		device_state_list.resize(0);
	}

	void wsTimerThread::send_tof_data()
	{
		if(tof_data_list.empty()){
			return;
		}

		try{
			std::lock_guard<std::mutex> lg(m_mtx);
			std::vector<tof_data> vtd;
			//vtd.insert(vtd.end(), tof_data_list.begin(), tof_data_list.end());
			vtd.swap(tof_data_list);
			std::string val = __jsBuilder.build_tof_data(vtd);
			swsClientMgr.send(JSON_CMD_VALUE_PUSH, val);

			//tof_data_list.clear();
			//std::vector<tof_data>().swap(tof_data_list);
			tof_data_list.clear();
			//tof_data_list.resize(0);
		}catch(std::exception& e){
			//log_error("[error] err=%s", e.what());
			log_error("[error] err=%s", e.what());
		}
	}

	void wsTimerThread::send_solid_ball_data()
	{
		if(sb_data_list.empty()){
			return;
		}
		
		try{
			std::lock_guard<std::mutex> lg(m_mtx);
			std::vector<sb_data> vts;
			vts.swap(sb_data_list);
			std::string val = __jsBuilder.build_sb_data(vts);
			swsClientMgr.send(JSON_CMD_VALUE_PUSH, val);
			sb_data_list.clear();
		}catch(std::exception& e){
			log_error("[error] err=%s", e.what());
		}
	}
    /*
     * 定时器线程发送定位数据
     *
     * */
	void wsTimerThread::_ThreadFunc( wsTimerThread * pOwner )
	{	
        //log_info("The timer thread is running");
        while ( pOwner->__Enable )
		{
			std::time_t t = time( 0 );
			int seconds = (int)std::difftime( t, __LastSendTime );

			if ( seconds >= pOwner->__Config.SendInterval )
			{
				pOwner->__SendCardPos();
                //service_position send
                //pOwner->send_card_pos();
                //pOwner->temp_send_card_pos();
                //pOwner->send_light_state();
				pOwner->send_device_state();
				pOwner->send_tof_data();
				__LastSendTime = t;
			}
			
			pOwner->send_solid_ball_data();

          	boost::this_thread::sleep( boost::posix_time::millisec( 1 ) );
		}

		pOwner->__ExitCond.notify_one();
	}

	void wsTimerThread::Init( const _THREAD_CONFIG_ & Config )
	{
		__Config = Config;
		__ChkConfig();
	}

	void wsTimerThread::upt_card_pos( const _CARD_POS_ & pos )
	{
		//如果已存在就更新，否则插入
		try{
			uint64_t type = pos.Type;
			uint64_t id=type<<32|pos.ID;
			if ( __CardPosList.seek( id  ) )
			{
				__CardPosList.update( id, pos );
			}
			else
			{
				__CardPosList.insert( id, pos );
			}
		}catch(std::exception& e){
			log_error("[error] err=%s", e.what());
		}
	}

    void wsTimerThread::real_upt_card_pos(const _CARD_POS_& pos)
    {
        std::string pos_json = __jsBuilder.build_ios_card_pos(pos);
        ios_service::m_ios_service->notify(pos_json, std::to_string(pos.ID), 10);
        log_info("[service-position] json: %s", pos_json.c_str());
    }

	void wsTimerThread::del_card_pos( const _CARD_POS_ & pos )
	{
		uint64_t type = pos.Type;
		uint64_t id=type<<32|pos.ID;
		__CardPosList.erase( id );
	}

    void wsTimerThread::upt_light_state(const light_state& light)
    {
        light_state_list.push_back(light);
    }

	void wsTimerThread::upt_device_state(const device_state& ds)
	{
		device_state_list.push_back(ds);
	}

	void wsTimerThread::upt_tof_data(const tof_data& td)
	{
		try{
			std::lock_guard<std::mutex> lg(m_mtx);
			tof_data_list.push_back(td);
		}catch(std::exception& e){
			std::string err = e.what();
			log_error("[error] err=%s", err.c_str());
		}
	}

	void wsTimerThread::upt_sb_data(const sb_data& val)
	{
		try{
			std::lock_guard<std::mutex> lg(m_mtx);
			sb_data_list.push_back(val);
		}catch(std::exception& e){
			log_error("[error] err=%s", e.what());
		}
	}
}