linux_door/jni/logic/mainLogic.cc

#pragma once
#include "uart/ProtocolSender.h"
#include "net/NetManager.h"
#include "storage/StoragePreferences.h"
#include "net/net.h"
#include <system/Thread.h>
#include "restclient-cpp/restclient.h"
#include "curl/curl.h"
#include <algorithm>
#include "service/BusinessConfig.h"
#include "core/sip_config.h"
#include "manager/LanguageManager.h"
#include "core/utilities.h"
#include <string>
#include "zkaudio.h"

#include "base/strings.hpp"
#include "base/http_client.h"
#include "os/UpgradeMonitor.h"
#include "core/jhws.h"
#include "core/update_assistant.h"
#include "utils/TimeHelper.h"


#define ETHERNETMANAGER		NETMANAGER->getEthernetManager()
#define WIFIMANAGER			NETMANAGER->getWifiManager()


/*
 *此文件由GUI工具生成
 *文件功能：用于处理用户的逻辑相应代码
 *功能说明：
 *========================onButtonClick_XXXX
当页面中的按键按下后系统会调用对应的函数，XXX代表GUI工具里面的[ID值]名称，
如Button1,当返回值为false的时候系统将不再处理这个按键，返回true的时候系统将会继续处理此按键。比如SYS_BACK.
 *========================onSlideWindowItemClick_XXXX(int index)
当页面中存在滑动窗口并且用户点击了滑动窗口的图标后系统会调用此函数,XXX代表GUI工具里面的[ID值]名称，
如slideWindow1;index 代表按下图标的偏移值
 *========================onSeekBarChange_XXXX(int progress)
当页面中存在滑动条并且用户改变了进度后系统会调用此函数,XXX代表GUI工具里面的[ID值]名称，
如SeekBar1;progress 代表当前的进度值
 *========================ogetListItemCount_XXXX()
当页面中存在滑动列表的时候，更新的时候系统会调用此接口获取列表的总数目,XXX代表GUI工具里面的[ID值]名称，
如List1;返回值为当前列表的总条数
 *========================oobtainListItemData_XXXX(ZKListView::ZKListItem *pListItem, int index)
 当页面中存在滑动列表的时候，更新的时候系统会调用此接口获取列表当前条目下的内容信息,XXX代表GUI工具里面的[ID值]名称，
如List1;pListItem 是贴图中的单条目对象，index是列表总目的偏移量。具体见函数说明
 *========================常用接口===============
 *LOGD(...)  打印调试信息的接口
 *mTextXXXPtr->setText("****") 在控件TextXXX上显示文字****
 *mButton1Ptr->setSelected(true); 将控件mButton1设置为选中模式，图片会切换成选中图片，按钮文字会切换为选中后的颜色
 *mSeekBarPtr->setProgress(12) 在控件mSeekBar上将进度调整到12
 *mListView1Ptr->refreshListView() 让mListView1 重新刷新，当列表数据变化后调用
 *mDashbroadView1Ptr->setTargetAngle(120) 在控件mDashbroadView1上指针显示角度调整到120度
 *
 * 在Eclipse编辑器中  使用 “alt + /”  快捷键可以打开智能提示
 */



TcpModel nursingTcpModel;
static bool dataInit = false;	// false表示需要从数据库里获取数据，true表示从缓存里获取数据
PartSetting partSetting;
Json::Value frameRoom;
Json::Value frameBedList;
Json::Value frameInfo;			// 缓存房间名字等
Json::Value rightTitleInfo;	// 缓存分机右边医生和护士标题
Json::Value painterInfo;
Json::Value painterInfoList;
static bool reinforce = false;	// 判断设备是否处于增援状态
static bool serverInfo = true;	// 判断是否需要从服务器获取服务器信息，第一次要，后续不要
static bool isHelpTimerRegistered = false;
static std::string cencalByDoorTid = "";



#define HELP_TIMER_HANDLE 3	// 增援的定时器id
#define EVENT_TIME_HANDLE 8		// 事件定时器
#define SLEEP_STRAT_TIME_HANDLE 9	// 息屏




//======================================= udp 请示服务器信息
static net::Conn* udpConn;
class UdpThread: public Thread {
public:
	static void getServerInfo(){

		string url = getHttpGateway() + "/ncs_url/server_info";
		LOGD("请求服务器信息. url = %s", url.c_str());
		//发起HTTP GET请求
		RestClient::Response r = RestClient::get(url);
		//解析json
		Json::Reader reader;
		Json::Value root;
		if (reader.parse(r.body, root, false)){
			// http
			StoragePreferences::putString(STORE_GATEWAY, root["http_local_ip"].asString());
			StoragePreferences::putInt(STORE_HTTP_PORT, root["http_port"].asInt());

			// tcp
			StoragePreferences::putString(STORE_TCP_LOCAL_IP, root["tcp_local_ip"].asString());
			StoragePreferences::putInt(STORE_TCP_PORT, root["tcp_port"].asInt());

			// sip
			StoragePreferences::putString(SIP_REG_DOMAIN, root["sip_ip"].asString());
			StoragePreferences::putInt(SIP_REG_PORT, root["sip_port"].asInt());

			serverInfo = false;	// 只有请求成功了，才不需要重复请求
		}

	}

	static void getDeviceInfo(){
		if (dataInit){
			getFrameInfo();
			//getPartSetting(StoragePreferences::getString(STORE_PARTID, ""));
			reinforceDispaly();
			return;
		}
		string url = getHttpGateway() + "/deviceRoom/get_device_by_eth_mac/" + StoragePreferences::getString(STORE_MAC_ADDR, "0.0.0.0");
		LOGD("请求设备信息. url = %s", url.c_str());
		//发起HTTP GET请求
		RestClient::Response r = RestClient::get(url);
		LOGD("获得设备信息. result = %s", r.body.c_str());
		//解析json
		Json::Reader reader;
		Json::Value root;
		if (reader.parse(r.body, root, false)){
			string partName = root["part_display"].asString();
			StoragePreferences::putString(STORE_PARTNAME,partName);
			NavibarSetPartName(partName);
			//设备
			StoragePreferences::putInt(STORE_DEVICE_ID, root["id"].asInt());
			StoragePreferences::putInt(STORE_DEVICE_TYPE, root["device_type"].asInt());

			//SIP存储
//			StoragePreferences::putString(SIP_REG_DOMAIN, root["sip_ip"].asString());	// 应该去找配置文件里的sip-ip
			StoragePreferences::putString(SIP_REG_ACCOUNT,root["sip_id"].asString());
			StoragePreferences::putString(SIP_REG_PASSWORD, root["sip_password"].asString());

			frameInfo["frame_id"] = root["frame_id"].asInt();
			frameInfo["full_name"] = root["full_name"].asString();
			frameInfo["part_id"] = root["part_id"].asInt();
			getFrameInfo();

			//获取科室设置
			string partId = root["part_id"].asString();
			StoragePreferences::putString(STORE_PARTID, partId);
			getPartSetting(partId);
			getVersion();
		}
	}
	// 读取空间缓存的数据
	static void getFrameInfo() {
		mRoomNamePtr->setText(frameInfo["full_name"].asString());
	}

	static void getFrameRoom(int frame_id) {
		string url = getHttpGateway() + "/deviceRoom/get_frame_room/" + to_string(frame_id);
		LOGD("请求房间信息. url = %s", url.c_str());
		//发起HTTP GET请求
		RestClient::Response r = RestClient::get(url);
		LOGD("获得房间信息. result = %s", r.body.c_str());
		//解析json
		Json::Reader reader;
		Json::Value root;
		if (reader.parse(r.body, root, false)){
			frameRoom = root;
			frameBedList = root["frame_bed_list"];
			if (mBedListViewPtr != NULL) {
				mBedListViewPtr->refreshListView();
			}
		}
	}


	static void getPartSetting(string partId){
		string url = getHttpGateway() + "/deviceBed/getPartSetting/" + partId;
		LOGD("请求科室信息. url = %s", url.c_str());
		//发起HTTP GET请求
		RestClient::Response r = RestClient::get(url);
		LOGD("获得科室信息. result = %s", r.body.c_str());
		//解析json
		Json::Reader reader;
		Json::Value root;
		if (reader.parse(r.body, root, false)){
			partSetting.partId = root["part_id"].asInt();
			partSetting.dayStart = root["day_start"].asString();
			partSetting.dayLight = root["day_light"].asInt();
			partSetting.dayVol = root["day_vol"].asInt();
			partSetting.dayRingVol = root["day_ring_vol"].asInt();
			partSetting.dayRingTimes = root["day_ring_times"].asInt();
			partSetting.dayNurseLed = root["day_nurse_led"].asInt();
			partSetting.dayDoorVol = root["day_door_vol"].asInt();
			partSetting.dayBedVol = root["day_bed_vol"].asInt();
			partSetting.dayTransferBoxVol = root["day_transfer_box_vol"].asInt();
			partSetting.dayTransferBoxSystemVol = root["day_transfer_box_system_vol"].asInt();
			partSetting.nightStart = root["night_start"].asString();
			partSetting.nightLight = root["night_light"].asInt();
			partSetting.nightVol = root["night_vol"].asInt();
			partSetting.nightRingVol = root["night_ring_vol"].asInt();
			partSetting.nightRingTimes = root["night_ring_times"].asInt();
			partSetting.nightNurseLed = root["night_nurse_led"].asInt();
			partSetting.nightDoorVol = root["night_door_vol"].asInt();
			partSetting.nightBedVol = root["night_bed_vol"].asInt();
			partSetting.nightTransferBoxVol = root["night_transfer_box_vol"].asInt();
			partSetting.nightTransferBoxSystemVol = root["night_transfer_box_system_vol"].asInt();
			partSetting.sleepSecondsNurse = root["sleep_seconds_nurse"].asInt();
			partSetting.sleepSecondsDoor = root["sleep_seconds_door"].asInt();
			partSetting.sleepSecondsBed = root["sleep_seconds_bed"].asInt();
			partSetting.sipOvertime = root["sip_overtime"].asInt();
			partSetting.transferDuration = root["transfer_duration"].asInt();
			partSetting.transferDurationLeader = root["transfer_duration_leader"].asInt();
			partSetting.communicationModeBed = root["communication_mode_bed"].asInt();
			partSetting.communicationModeNurse = root["communication_mode_nurse"].asInt();
			partSetting.communicationModeMobile = root["communication_model_mobile"].asInt();
			partSetting.customizeRoleCallFirst = root["customize_role_call_first"].asInt();
			partSetting.customizeRoleCallSecond = root["customize_role_call_second"].asInt();
			partSetting.customizeRoleCallThird = root["customize_role_call_third"].asInt();
			partSetting.customizeRoleCallFourth = root["customize_role_call_fourth"].asInt();
			partSetting.customizeRoleCallFifth = root["customize_role_call_fifth"].asInt();
			partSetting.customizeHospitalCallFirst = root["customize_hospital_call_first"].asInt();
			partSetting.customizeHospitalCallFirstName = root["customize_hospital_call_first_name"].asString();
			partSetting.customizeHospitalCallSecond = root["customize_hospital_call_second"].asInt();
			partSetting.customizeHospitalCallSecondName = root["customize_hospital_second_name"].asString();
			partSetting.customizeHospitalCallThird = root["customize_hospital_call_third"].asInt();
			partSetting.customizeHospitalCallThirdName = root["customize_hospital_call_third_name"].asString();
			partSetting.doctorTitle = root["doctor_title"].asString();
			partSetting.doctorValid = root["doctor_valid"].asInt();
			partSetting.nurseTitle = root["nurse_title"].asString();
			partSetting.nurseValid = root["nurse_valid"].asInt();
			partSetting.doorNurseTitle = root["door_nurse_title"].asString();
			partSetting.doorNurseValid = root["door_nurse_valid"].asInt();
			partSetting.doorNursingTitle = root["door_nursing_title"].asString();
			partSetting.doorNursingValid = root["door_nursing_valid"].asInt();
			partSetting.upSeconds = root["up_seconds"].asInt();
			partSetting.autoAccept = root["auto_accept"].asInt();
			partSetting.eventForward = root["event_forward"].asInt();
			partSetting.nursingColorRgb = root["nursing_color_rgb"].asString();
			partSetting.twoColorDoorLightValid = root["two_color_door_light_valid"].asInt();
			partSetting.qrUrl = root["qr_url"].asString();
			partSetting.screenLight = root["screen_light"].asInt();
			partSetting.roomCallBed = root["room_call_bed"].asInt();

			if (root["linux_door_volume_native"].size() != 0) {
				partSetting.linuxDoorVolumeNative = root["linux_door_volume_native"].asInt();
				partSetting.linuxDoorGainSize = root["linux_door_gain_size"].asInt();

				zk_audio_input_set_volume_native(0, 0);
				zk_audio_input_set_volume_native(1, partSetting.linuxDoorVolumeNative);
				GetTelephone()->SetInputPcmGainSize(partSetting.linuxDoorGainSize);

				StoragePreferences::putInt(STORE_VOLUME_NATIVE, partSetting.linuxDoorVolumeNative);
				StoragePreferences::putInt(STORE_GAIN_SIZE, partSetting.linuxDoorGainSize);
			}

			StoragePreferences::putString(STORE_DAY_START, partSetting.dayStart);
			StoragePreferences::putInt(STORE_DAY_LIGHT,partSetting.dayLight);
			StoragePreferences::putInt(STORE_DAY_VOL,partSetting.dayBedVol);
			StoragePreferences::putInt(STORE_DAY_RING_TIMES,partSetting.dayRingTimes);

			StoragePreferences::putString(STORE_NIGHT_START, partSetting.nightStart);
			StoragePreferences::putInt(STORE_NIGHT_LIGHT,partSetting.nightLight);
			StoragePreferences::putInt(STORE_NIGHT_VOL,partSetting.nightBedVol);
			StoragePreferences::putInt(STORE_NIGHT_RING_TIMES,partSetting.nightRingTimes);

			StoragePreferences::putInt(STORE_SLEEP_TIME, partSetting.sleepSecondsDoor);

			StoragePreferences::putString(STORE_DOCTOR_TITLE, partSetting.doctorTitle);
			StoragePreferences::putBool(STORE_DOCTOR_VISIBLE, partSetting.doctorValid==1);
			StoragePreferences::putString(STORE_NURSE_TITLE, partSetting.nurseTitle);
			StoragePreferences::putBool(STORE_NURSE_VISIBLE, partSetting.nurseValid==1);

			StoragePreferences::putString(STORE_NURSING_COLOR_RGB, partSetting.nursingColorRgb);
			StoragePreferences::putBool(STORE_AUDO_ANSWER, partSetting.autoAccept==1);
			StoragePreferences::putInt(STORE_SCREEN_LIGHT, partSetting.screenLight);
			StoragePreferences::putInt(STORE_ROOM_CALL_BED, partSetting.roomCallBed);

			setRightTitle(root);
			callBedButtonSetVisible();

			getFrameRoom(frameInfo["frame_id"].asInt());

			dataInit = true;
		}
	}

	static void callBedButtonSetVisible() {
		int roomCallBed = StoragePreferences::getInt(STORE_ROOM_CALL_BED, 1);
		if (!roomCallBed) {
			// 如果roomCallBed是0的话，那就隐藏
			mCallBedButtonPtr->setVisible(roomCallBed);

			mCallNurseButtonPtr->setPosition(LayoutPosition(869, 190, 140, 55));
			mCallCencelButtonPtr->setPosition(LayoutPosition(869, 280, 140, 55));
			mHelpButtonPtr->setPosition(LayoutPosition(869, 370, 140, 55));
//			mNursingButtonPtr->setPosition(LayoutPosition(869, 404, 140, 55));
			mMoreButtonPtr->setPosition(LayoutPosition(869, 460, 140, 55));

		}
		else {
			// 如果roomCallBed是1的话，那就显示
			mCallBedButtonPtr->setVisible(roomCallBed);

			mCallNurseButtonPtr->setPosition(LayoutPosition(869, 255, 140, 55));
			mCallCencelButtonPtr->setPosition(LayoutPosition(869, 330, 140, 55));
			mHelpButtonPtr->setPosition(LayoutPosition(869, 405, 140, 55));
//			mNursingButtonPtr->setPosition(LayoutPosition(869, 420, 140, 55));
			mMoreButtonPtr->setPosition(LayoutPosition(869, 480, 140, 55));
		}
	}

	// 将医生和护士别称缓存起来
	static void setRightTitle(Json::Value partSetting) {
		rightTitleInfo["doctor_title"] = partSetting["doctor_title"].asString();
		rightTitleInfo["doctor_valid"] = partSetting["doctor_valid"].asInt();
		rightTitleInfo["nurse_title"] = partSetting["nurse_title"].asString();
		rightTitleInfo["nurse_valid"] = partSetting["nurse_valid"].asInt();
	}


	static void getVersion() {
		std::string url = getHttpGateway() + "/deviceRoom/get_app_version?device_type=303&part_id=" + StoragePreferences::getString(STORE_PARTID, "");
		std::string content_type = std::string("application/json");

		LOGD("请求版本信息. url = %s", url.c_str());
		//发起HTTP POST请求
		RestClient::Response r = RestClient::post(url, content_type, "");
		if (r.code != 200) {
			LOGD("请求版本信息-> 错误代码： %d", r.code);
			return;
		}

		LOGD("获得版本信息. result = %s", r.body.c_str());
		//解析json
		Json::Reader reader;
		Json::Value root;

		if(reader.parse(r.body, root, false)) {
			int currentVersionNo = getVersionNo();
			int responseVersionNo = root["version_no"].asInt();
			std::string responseVersion = root["version_code"].asString();
			LOGD("服务器版本 : %s %d, 当前设备版本: %d", responseVersion.c_str(), responseVersionNo, currentVersionNo);

			if (currentVersionNo < responseVersionNo) {
				Intent* intent = new Intent();
				intent->putExtra(appUpdate, "true");
				EASYUICONTEXT->openActivity("DeviceUpdateActivity", intent);
			}
		}

	}

	// 判断是否处于增援状态，处于增援状态，就要显示蓝色
	static void reinforceDispaly() {
		if (reinforce) {
//			SetPainterInfo(0xFF2F9DF1, "增援已发出");
//			setHelpButton("/button/button_help3.png" ,false);
			setPainterInfo(StoragePreferences::getInt(STORE_DEVICE_ID,0), 0xFF2F9DF1, LANGUAGEMANAGER->getValue("HelpInfo"), "REINFORCE", "ADD", 60);
		}
	}


	/**
	 * 线程创建成功后会调用该函数，可以在该函数中做一些初始化操作
	 * return true   继续线程
	 *        false  退出线程
	 */
	virtual bool readyToRun() {
		LOGD("Thread 已经创建完成");
		return true;
	}

	/**
	 * 线程循环函数
	 *
	 * return true  继续线程循环
	 *        false 推出线程
	 */
	virtual bool threadLoop() {
		LOGD("线程循环函数");

		//检查是否有退出线程的请求，如果有，则返回false，立即退出线程
		if (exitPending()) {
			return false;
		}

		udpConn = net::Dial("udp", "192.168.1.255:10010");
		if (udpConn) {
			byte buf[1024] = {0};
			const char* req = "search_server";
			//发送
			udpConn->Write((byte*)req, strlen(req));
			while (true && !exitPending()) {
				//读取，超时10*1000毫秒
				int n = udpConn->Read(buf, sizeof(buf) - 1, 10*1000);
				if (n > 0) {
					buf[n] = 0;
					char serverStr[1024];
					sprintf(serverStr,"%s",buf);
					LOGD("读取 %d字节： %s", n, serverStr);

					//解析json
					Json::Reader reader;
					Json::Value root;
					if (reader.parse(serverStr, root, false)){
						if (root.isMember("success") && root["success"].asBool()){
							serverIP = root["data"]["third_server"].asString();
							serverHttpPort = root["data"]["third_server_port"].asInt();

							StoragePreferences::putString(STORE_GATEWAY, serverIP);
							StoragePreferences::putInt(STORE_HTTP_PORT, serverHttpPort);

							//先获取服务器信息
							//getServerInfo();
							//就当在获取服务器信息完成后获取用户信息，这里测试用
							//getCustomerInfo();
							//退出UDP线程
							pthread_exit(NULL);
							break;
						}
					}
				} else if (n == 0) {
					LOGD("连接正常断开");
					break;
				} else if (n == net::E_TIMEOUT) {
					udpConn->Write((byte*)req, strlen(req));
					LOGD("读取超时");
				} else {
					LOGD("出错");
					break;
				}
			}
			//关闭连接
			udpConn->Close();
			//释放内存
			delete udpConn;
			udpConn = NULL;
		}

		//返回真，继续下次线程循环
		return true;
	}
};

static UdpThread udp_thread;


void setReinforce(bool result) {
	reinforce = result;
}

void setHelpButton(const char *pPicPath, bool isTouchable){
	mHelpButtonPtr->setButtonStatusPic(ZK_CONTROL_STATUS_NORMAL, pPicPath);
	mHelpButtonPtr->setTouchable(isTouchable);
}

void cancelAutoBtnHelpTimer(){
	if (isHelpTimerRegistered) {
		mActivityPtr->unregisterUserTimer(HELP_TIMER_HANDLE);
		 isHelpTimerRegistered = false;
	 }
}

std::string getCencalByDoorTid() {
	return cencalByDoorTid;
}

int getNowTime() {
	struct tm *t = TimeHelper::getDateTime();
	char timeStr[50];
	string formatStr = "%02d:%02d:%02d";
	sprintf(timeStr, formatStr.c_str(), t->tm_hour,t->tm_min,t->tm_sec);
	int hour, minute, second;// 定义时间的各个int临时变量。
	sscanf(timeStr, "%d:%d:%d", &hour, &minute, &second);
	int time = hour * 60 * 60 + minute * 60 +  second;
	return time;
}


Json::Value getPainterInfoList() {
	return painterInfoList;
}


void addPainterInfo(int deviceId, uint32_t bgColor, const std::string& msg, const std::string type, int endTime) {
	// 将设备id，颜色，展示的信息，时间存放起来
	painterInfo["deviceId"] = deviceId;
//	painterInfo["bgColor"] = bgColor + "";
	painterInfo["bgColor"] = bgColor;
	painterInfo["msg"] = msg;
	painterInfo["type"] = type;
	painterInfo["endTime"] = getNowTime() + endTime;
	painterInfoList.append(painterInfo);
}


bool removePainterInfo(int deviceId, const std::string type) {
	// 获取painterInfoList的长度
	int size = painterInfoList.size();
	if (size == 0) {	// 如果为空了，那就代表painterInfoList没有值，直接返回
		return false;
	}

	// 如果painterInfoList里有对应的deviceId，那就需要先删除原本的，然后再从头添加新的
	int removeIndex = -1;
	for (int i = 0; i < painterInfoList.size(); i++) {
		LOGD("deviceId == %d", deviceId);
		LOGD("painterInfoList.deviceId == %d", painterInfoList[i]["deviceId"].asInt());
		LOGD("type == %s", type.c_str());
		LOGD("painterInfoList.type == %s", painterInfoList[i]["type"].asCString());
		if (painterInfoList[i]["deviceId"].asInt() == deviceId && painterInfoList[i]["type"].asString() == type) {
			removeIndex = i;
		}
	}

	if (removeIndex != -1) {
		painterInfoList.removeIndex(removeIndex, &painterInfo);
	}

	return true;
}


//标识方法
void setPainterInfo(int deviceId, uint32_t bgColor, const std::string& msg, const std::string type, const std::string handle, int endTime) {
	if (handle == "ADD") {	// 进行添加，如果painterInfoList为空时，添加需要启动定时器
		int size = painterInfoList.size();
		removePainterInfo(deviceId, type);
		addPainterInfo(deviceId, bgColor, msg, type, endTime);

		if (size == 0) {
			mActivityPtr->registerUserTimer(HELP_TIMER_HANDLE, 1000);	// 每秒检测一次
		}

		if (type == "REINFORCE") {	// 增援添加的时候，需要禁用增援按钮
			setReinforce(true);		// 设置增援状态为true
			setHelpButton("/button/button_help3.png", false);
		}
	}
	else if (handle == "UPDATE") {	// 进行修改时，需要把原本的删除掉，再进行添加
		bool result = removePainterInfo(deviceId, type);
		addPainterInfo(deviceId, bgColor, msg, type, endTime);
		if (!result) {
			mActivityPtr->registerUserTimer(HELP_TIMER_HANDLE, 1000);	// 每秒检测一次
		}
	}
	else if (handle == "DELETE") {	// 进行删除
		removePainterInfo(deviceId, type);

		if (type == "REINFORCE") {	// 增援删除的时候，需要还原增援按钮的图片
			setReinforce(false);
			setHelpButton("/button/button_help2.png", true);
		}
	}

	LOGD("painterInfoList.size() == %d", painterInfoList.size());

	mPainterInfoPtr->setBackgroundColor(bgColor);
	mTextInfoPtr->setText(msg);
	if (bgColor == 0xFFFFFFFF){
		mRoomNamePtr->setTextColor(0x00AAF4);
	} else {
		mRoomNamePtr->setTextColor(0xFFFFFF);
	}
}

// 收到tcp的时候，刷新数据
void dataRefresh() {
	LOGD("DATA-REFRESH, 数据刷新");

	if (mActivityPtr == NULL) {
		return;
	}

	if (serverInfo) {
		udp_thread.getServerInfo();
	}
	dataInit = false;
	udp_thread.getDeviceInfo();
	mBedListViewPtr->refreshListView();
}

void getPartSetting() {
	udp_thread.getPartSetting(StoragePreferences::getString(STORE_PARTID, ""));
}


// 处理护理的tcpModel
void setNursingTcpModel(TcpModel tcpModel) {
	LOGD("缓存Nursing的tcpModel ！！！");
	nursingTcpModel = tcpModel;
}

void sendNursingEnd() {
	StoragePreferences::putBool(STORE_NURSING_TYPE, false);

//	std::string heartStr = "DOORLED,000F";
//	const char* sendMsg = heartStr.c_str();
//	sendProtocolTo(UART_TTYS2, (byte*)(sendMsg), strlen(sendMsg));
	lightControl("DOORLED", "000F");

	if (StoragePreferences::getString(STORE_NURSING_INTERACTION_ID, "") != "") {	// 对比一下，json里面不为空的时候

		// 发送tcp, tcp_type = SIDE, tcp_action = NURSING_END
		TcpModel tcpModel;
		tcpModel.tid = base::format("t%d", TimeHelper::getCurrentTime());
		tcpModel.type = TcpType::SIDE;
		tcpModel.action = SideAction::NURSING_END;
		tcpModel.from_id = StoragePreferences::getInt(STORE_DEVICE_ID,0);
		tcpModel.data = StoragePreferences::getString(STORE_NURSING_INTERACTION_ID, "");	// 获取nursingTcpModel里，id字段的数据

		std::string req = getTcpModelString(tcpModel);
		LOGD("TCP NURSING_END : %s",req.c_str());
//			TcpClient::instance()->sendMsg(req.c_str());

		//回调注册
		TcpCallback callback;
		callback.tid = tcpModel.tid;
		callback.jsonStr = req;
		callback.onSuccess = [](Json::Value json){
			LOGD("event callback success");
			return 0;
		};
		callback.onFalied = [](Json::Value json){
			LOGD("event callback failed");
			return 0;
		};
		TcpClient::instance()->sendMsgWithCb(req.c_str(), callback);

		TcpModel newTcpModel;
		// 需要把护理的interactionId清空
		StoragePreferences::putString(STORE_NURSING_INTERACTION_ID, "");
	}
}

/**
 * 注册定时器
 * 填充数组用于注册定时器
 * 注意：id不能重复
 */
static S_ACTIVITY_TIMEER REGISTER_ACTIVITY_TIMER_TAB[] = {
		//{0,  6000}, //定时器id=0, 时间间隔6秒
		//{1,  1000},
};

/**
 * 当界面构造时触发
 */
static void onUI_init(){
	//udp_thread.run("this is thread name");
	//测试用
	LOGD("进入mainLogic页面， 触发 onUI_init");
	if (ETHERNETMANAGER->isConnected() || WIFIMANAGER->isConnected()) {
		if(serverInfo) {	// 如果是false，就是不需要
			udp_thread.getServerInfo();
		}
		udp_thread.getDeviceInfo();
	}

	if (StoragePreferences::getBool(STORE_NURSING_TYPE, false)) {	// 如果处于护理状态
		mFunctionWinPtr->showWnd();
		mFunctionTextViewPtr->setText(LANGUAGEMANAGER->getValue("InNursing"));
		mFunctionButtonPtr->setText(LANGUAGEMANAGER->getValue("NursingEnd"));
		mFunctionBackPtr->setVisible(false);
	} else {
		mFunctionWinPtr->hideWnd();
	}
}

/**
 * 当切换到该界面时触发
 */
static void onUI_intent(const Intent *intentPtr) {
	if (intentPtr != NULL) {
	}

}

/*
 * 当界面显示时触发
 */
static void onUI_show() {

}

/*
 * 当界面隐藏时触发
 */
static void onUI_hide() {

}

/*
 * 当界面完全退出时触发
 */
static void onUI_quit() {
	//pthread_exit(NULL);
}

/**
 * 串口数据回调接口
 */
static void onProtocolDataUpdate(const SProtocolData &data) {

}

/**
 * 定时器触发函数
 * 不建议在此函数中写耗时操作，否则将影响UI刷新
 * 参数： id
 *         当前所触发定时器的id，与注册时的id相同
 * 返回值: true
 *             继续运行当前定时器
 *         false
 *             停止运行当前定时器
 */
static bool onUI_Timer(int id){
	switch (id) {

	case HELP_TIMER_HANDLE:	// 不能在线程里面关掉线程
		{
//			SetPainterInfo(0xFFFFFFFF, "");
//			setReinforce(false);
//			setHelpButton("/button/button_help2.png", true);
//			return false;

			if (painterInfoList.size() > 0) {	// painterInfoList代表里面存在内容

				// 取出排列最后的一项，判断列表是否超时，没有超时就将内容填充到里面
				Json::Value _painterInfo;

				_painterInfo = painterInfoList.get(painterInfoList.size() - 1, &painterInfo);
				int nowTime = getNowTime();
				if (nowTime >= _painterInfo["endTime"].asInt()) {
					if (_painterInfo["type"] == "REINFORCE") {
						setReinforce(false);
						setHelpButton("/button/button_help2.png", true);
					}
					painterInfoList.removeIndex(painterInfoList.size() - 1, &painterInfo);
				} else {
					mPainterInfoPtr->setBackgroundColor( _painterInfo["bgColor"].asUInt());
					mTextInfoPtr->setText(_painterInfo["msg"].asCString());
					if (_painterInfo["bgColor"] == 0xFFFFFFFF){
						mRoomNamePtr->setTextColor(0x00AAF4);
					} else {
						mRoomNamePtr->setTextColor(0xFFFFFF);
					}
				}

			} else {
				mPainterInfoPtr->setBackgroundColor(0xFFFFFFFF);
				mTextInfoPtr->setText("");
				mRoomNamePtr->setTextColor(0x00AAF4);
				setReinforce(false);
				setHelpButton("/button/button_help2.png", true);
				return false;
			}
		}
		break;
	default:
		break;
	}
	return true;
}

/**
 * 有新的触摸事件时触发
 * 参数：ev
 *         新的触摸事件
 * 返回值：true
 *            表示该触摸事件在此被拦截，系统不再将此触摸事件传递到控件上
 *         false
 *            触摸事件将继续传递到控件上
 */
static bool onmainActivityTouchEvent(const MotionEvent &ev) {
	switch (ev.mActionStatus) {
	case MotionEvent::E_ACTION_DOWN://触摸按下
		//LOGD("时刻 = %ld 坐标  x = %d, y = %d", ev.mEventTime, ev.mX, ev.mY);
		break;
	case MotionEvent::E_ACTION_MOVE://触摸滑动
		break;
	case MotionEvent::E_ACTION_UP:  //触摸抬起
		break;
	default:
		break;
	}
	return false;
}
static int getListItemCount_BedListView(const ZKListView *pListView) {
    //LOGD("getListItemCount_BedListView !\n");
	if (frameBedList.size() > 3) {
		return frameBedList.size();
	}
	return 3;
}

static void obtainListItemData_BedListView(ZKListView *pListView,ZKListView::ZKListItem *pListItem, int index) {
    //LOGD(" obtainListItemData_ BedListView  !!!\n");
	if (frameBedList.size() > 0) {
		string frameBedName = frameBedList[index]["frame_bed"]["full_name"].asString();
		if (frameBedName == "") {
			pListItem->findSubItemByID(ID_MAIN_BedFrameTextView)->setText(LANGUAGEMANAGER->getValue("EmptyBed"));
		} else {
			int nPos = frameBedName.find("-");
			if (nPos != -1) {
				frameBedName = frameBedName.substr(nPos + 1, frameBedName.length());
			}
			pListItem->findSubItemByID(ID_MAIN_BedFrameTextView)->setText(frameBedName);
		}

		// 用户相关
		string customerName = frameBedList[index]["customer_name"].asString();
		if (customerName == "") {
			pListItem->findSubItemByID(ID_MAIN_CustomerName)->setText(LANGUAGEMANAGER->getValue("EmptyCustomer"));
		} else {
			pListItem->findSubItemByID(ID_MAIN_CustomerName)->setText(customerName);
		}
		pListItem->findSubItemByID(ID_MAIN_CustomerAge)->setText(frameBedList[index]["customer_age"].asString() + frameBedList[index]["customer_age_unit"].asString());

		string customerSex = frameBedList[index]["customer_sex"].asString();
		if (customerSex == "0") {	// 如果性别为女性，则替换成女性头像，和女性的图标
			pListItem->findSubItemByID(ID_MAIN_CustomerPortrait)->setBackgroundPic("ic_custom_female.png");
			pListItem->findSubItemByID(ID_MAIN_CustomerSex)->setBackgroundPic("ic_gender_female.png");
		}
		else if (customerSex == "1") {
			pListItem->findSubItemByID(ID_MAIN_CustomerPortrait)->setBackgroundPic("ic_custom_male.png");
			pListItem->findSubItemByID(ID_MAIN_CustomerSex)->setBackgroundPic("ic_gender_male.png");
		}
		else {
			pListItem->findSubItemByID(ID_MAIN_CustomerPortrait)->setBackgroundPic("ic_custom_empty.png");
			pListItem->findSubItemByID(ID_MAIN_CustomerSex)->setBackgroundPic("");
		}


		// 医生护士相关
		if (rightTitleInfo["doctor_valid"] != 1){
			pListItem->findSubItemByID(ID_MAIN_DoctorText)->setVisible(false);
		} else {
			pListItem->findSubItemByID(ID_MAIN_DoctorText)->setText(rightTitleInfo["doctor_title"].asString());
		}

		if (rightTitleInfo["nurse_valid"] != 1){
			pListItem->findSubItemByID(ID_MAIN_NurseText)->setVisible(false);
		} else {
			pListItem->findSubItemByID(ID_MAIN_NurseText)->setText(rightTitleInfo["nurse_title"].asString());
		}
		pListItem->findSubItemByID(ID_MAIN_DoctorName)->setText(frameBedList[index]["doctor_name"].asString());
		pListItem->findSubItemByID(ID_MAIN_NurseName)->setText(frameBedList[index]["nurse_name"].asString());


//		// 护理项相关
//		Json::Value nurseConfigList = frameBedList[index]["nurse_config_dtos"];
//		if (nurseConfigList.size() > 0) {
//			for (int i = 0; i < 5; i++) {
//				int nurseConfigColorNumber = ID_MAIN_NurseConfigColor1 + i;
//				int nurseConfigNumber = ID_MAIN_NurseConfig1 + i * 2;
//				int nurseOptionNumber = ID_MAIN_NurseOption1 + i * 2;
//				if (nurseConfigList.size() >= i) {
//					//颜色
//					string nurseConfigColot = nurseConfigList[i]["nurse_color_rbg"].asString();
//					uint32_t bgColor = 0xFFC0C0C0;
//					if (nurseConfigColot != "") {
//						string rgbStr = "FF" + nurseConfigColot;
//						transform(rgbStr.begin(), rgbStr.end(), rgbStr.begin(), ::toupper);
//						bgColor = strtoul(("0x" + rgbStr).c_str(), NULL,16);
//					}
//					pListItem->findSubItemByID(nurseConfigColorNumber)->setBackgroundColor(bgColor);
//					pListItem->findSubItemByID(nurseConfigNumber)->setText(nurseConfigList[i]["nurse_config_name"].asString());
//					string nurseOptionName = nurseConfigList[i]["nurse_option_name"].asString();
//					if (nurseOptionName == "") {
//						nurseOptionName = LANGUAGEMANAGER->getValue("None");
//					}
//					pListItem->findSubItemByID(nurseOptionNumber)->setText(nurseOptionName);
//
//				} else {
//					//颜色
//					pListItem->findSubItemByID(nurseConfigColorNumber)->setBackgroundColor(0xFFC0C0C0);
//					pListItem->findSubItemByID(nurseConfigNumber)->setText(nurseConfigList[i]["nurse_config_name"].asString());
//					pListItem->findSubItemByID(nurseOptionNumber)->setText(LANGUAGEMANAGER->getValue("None"));
//				}
//			}
//		}
//		else {
//			pListItem->findSubItemByID(ID_MAIN_NurseConfigColor1)->setBackgroundColor(0xFFC0C0C0);
//			pListItem->findSubItemByID(ID_MAIN_NurseConfigColor2)->setBackgroundColor(0xFFC0C0C0);
//			pListItem->findSubItemByID(ID_MAIN_NurseConfigColor3)->setBackgroundColor(0xFFC0C0C0);
//			pListItem->findSubItemByID(ID_MAIN_NurseConfigColor4)->setBackgroundColor(0xFFC0C0C0);
//			pListItem->findSubItemByID(ID_MAIN_NurseConfigColor5)->setBackgroundColor(0xFFC0C0C0);
//			pListItem->findSubItemByID(ID_MAIN_NurseConfig1)->setText("");
//			pListItem->findSubItemByID(ID_MAIN_NurseConfig2)->setText("");
//			pListItem->findSubItemByID(ID_MAIN_NurseConfig3)->setText("");
//			pListItem->findSubItemByID(ID_MAIN_NurseConfig4)->setText("");
//			pListItem->findSubItemByID(ID_MAIN_NurseConfig5)->setText("");
//			pListItem->findSubItemByID(ID_MAIN_NurseOption1)->setText(LANGUAGEMANAGER->getValue("None"));
//			pListItem->findSubItemByID(ID_MAIN_NurseOption2)->setText(LANGUAGEMANAGER->getValue("None"));
//			pListItem->findSubItemByID(ID_MAIN_NurseOption3)->setText(LANGUAGEMANAGER->getValue("None"));
//			pListItem->findSubItemByID(ID_MAIN_NurseOption4)->setText(LANGUAGEMANAGER->getValue("None"));
//			pListItem->findSubItemByID(ID_MAIN_NurseOption5)->setText(LANGUAGEMANAGER->getValue("None"));
//		}
	}
}

static void onListItemClick_BedListView(ZKListView *pListView, int index, int id) {
    //LOGD(" onListItemClick_ BedListView  !!!\n");
}
static bool onButtonClick_CallBedButton(ZKButton *pButton) {
    LOGD(" ButtonClick CallBedButton !!!\n");

    if (frameBedList.size() > 0) {
    	mCallBebWinPtr->showWnd();
    } else {
		Intent* intent = new Intent();
		intent->putExtra(warnText, LANGUAGEMANAGER->getValue("NoBedList"));
		EASYUICONTEXT->openActivity("warnActivity", intent);
    }
    return false;
}

static bool onButtonClick_CallNurseButton(ZKButton *pButton) {
    LOGD(" ButtonClick CallNurseButton !!!\n");

	if (StoragePreferences::getString(STORE_SIGNAL_TYPE, SIGNAL_TYPE) == "SIP"){
		int port = StoragePreferences::getInt(SIP_REG_PORT, SIP_REG_PORT_DEFAULT);
		std::string domain = StoragePreferences::getString(SIP_REG_DOMAIN, SIP_REG_DOMAIN_DEFAULT);
		std::string od_number = StoragePreferences::getString(SIP_REG_DOOR_ACCOUNT, SIP_REG_DOOR_ACCOUNT_DEFAULT);
		std::string od_number_uri = URI(od_number, domain, port);
		LOGD("od_number_uri: %s", od_number_uri.c_str());
		GetTelephone()->MakeCall(od_number_uri);
	} else {
        Intent* intent = new Intent();
        intent->putExtra(isOutgoing, "true");
        intent->putExtra(audioOnly, "true");
        EASYUICONTEXT->openActivity("callActivity", intent);
    }

    return false;
}

static bool onButtonClick_HelpButton(ZKButton *pButton) {
    LOGD(" ButtonClick HelpButton !!!\n");

	TcpModel tcpModel;
	tcpModel.type = TcpType::REINFORCE;
	tcpModel.action = ReinforceAction::CALL;
	tcpModel.from_id = StoragePreferences::getInt(STORE_DEVICE_ID,0);
	tcpModel.to_id = 0;
	std::string req = getTcpModelString(tcpModel);
	LOGD("REINFORCE CALL : %s",req.c_str());
//	TcpClient::instance()->sendMsg(req.c_str());

	//回调注册
	TcpCallback callback;
	callback.tid = tcpModel.tid;
	callback.jsonStr = req;
	callback.onSuccess = [](Json::Value json){
		LOGD("callback success");
		return 0;
	};
	callback.onFalied = [](Json::Value json){
		LOGD("callback failed");
		return 0;
	};
	TcpClient::instance()->sendMsgWithCb(req.c_str(), callback);

//	setHelpButton("/button/button_help3.png" ,false);
//	SetPainterInfo(0xFF2F9DF1, "增援已发出");
//	setReinforce(true);		// 设置增援状态为true
//	//1分钟后无响应还原颜色
//	if (!isHelpTimerRegistered){
//		mActivityPtr->registerUserTimer(HELP_TIMER_HANDLE, 60000);
//	}

	setPainterInfo(StoragePreferences::getInt(STORE_DEVICE_ID,0), 0xFF2F9DF1, LANGUAGEMANAGER->getValue("HelpInfo"), "REINFORCE", "ADD", 60);
    return false;
}

static bool onButtonClick_CallCencelButton(ZKButton *pButton) {

    LOGD(" ButtonClick CallCencelButton !!!\n");
    // 发送tcp, tcp_type = VOICE, tcp_action = CANCEL_BY_DOOR
	TcpModel tcpModel;
	tcpModel.tid = base::format("t%d",TimeHelper::getCurrentTime());
	tcpModel.type = TcpType::VOICE;
	tcpModel.action = VoiceAction::CANCEL_BY_DOOR;
	tcpModel.from_id = StoragePreferences::getInt(STORE_DEVICE_ID,0);
	tcpModel.to_id = NULL;
	std::string req = getTcpModelString(tcpModel);
	LOGD("TCP VOICE : %s",req.c_str());

	cencalByDoorTid = tcpModel.tid;

	//回调注册
	TcpCallback callback;
	callback.tid = tcpModel.tid;
	callback.jsonStr = req;
	callback.onSuccess = [](Json::Value json){
		LOGD("side callback success");
		return 0;
	};
	callback.onFalied = [](Json::Value json){
		LOGD("side callback failed");
		return 0;
	};
	TcpClient::instance()->sendMsgWithCb(req.c_str(), callback);
    return false;
}

static bool onButtonClick_NursingButton(ZKButton *pButton) {
    LOGD(" ButtonClick NursingButton !!!\n");

//	std::string color = StoragePreferences::getString(STORE_NURSING_COLOR_RGB, "010");
//	std::string heartStr;
//	if (color != "" && color.size() == 3) {
//		heartStr = "DOORLED," + color + "F";
//	} else {
//		heartStr = "DOORLED,010F";
//	}
//	const char* sendMsg = heartStr.c_str();
//	sendProtocolTo(UART_TTYS2, (byte*)(sendMsg), strlen(sendMsg));
	std::string color = StoragePreferences::getString(STORE_NURSING_COLOR_RGB, "010");
	if (color != "" && color.size() == 3) {
		color = color + "F";
	} else {
		color = "010F";
	}
	lightControl("DOORLED", color);

	mFunctionWinPtr->showWnd();
	mFunctionTextViewPtr->setText(LANGUAGEMANAGER->getValue("InNursing"));
	mFunctionButtonPtr->setText(LANGUAGEMANAGER->getValue("NursingEnd"));
	mFunctionBackPtr->setVisible(false);

	// 发送tcp, tcp_type = SIDE, tcp_action = NURSING
	TcpModel tcpModel;
	tcpModel.tid = base::format("t%d",TimeHelper::getCurrentTime());
	tcpModel.type = TcpType::SIDE;
	tcpModel.action = SideAction::NURSING;
	tcpModel.from_id = StoragePreferences::getInt(STORE_DEVICE_ID,0);
	tcpModel.to_id = NULL;
	std::string req = getTcpModelString(tcpModel);
	LOGD("TCP SIDE : %s",req.c_str());

	//回调注册
	TcpCallback callback;
	callback.tid = tcpModel.tid;
	callback.jsonStr = req;
	callback.onSuccess = [](Json::Value json){
		LOGD("side callback success");
		return 0;
	};
	callback.onFalied = [](Json::Value json){
		LOGD("side callback failed");
		return 0;
	};
	TcpClient::instance()->sendMsgWithCb(req.c_str(), callback);

	// 把护理状态缓存起来
	StoragePreferences::putBool(STORE_NURSING_TYPE, true);
    return false;
}

static bool onButtonClick_MoreButton(ZKButton *pButton) {
    LOGD(" ButtonClick MoreButton !!!\n");
	EASYUICONTEXT->openActivity("ui3Activity");
    return false;
}

static bool onButtonClick_FunctionButton(ZKButton *pButton) {
    LOGD(" ButtonClick FunctionButton !!!\n");
	mFunctionWinPtr->hideWnd();
	sendNursingEnd();
    return false;
}

static bool onButtonClick_FunctionBack(ZKButton *pButton) {
    LOGD(" ButtonClick FunctionBack !!!\n");
    return false;
}
static int getListItemCount_CallBedListView(const ZKListView *pListView) {
    //LOGD("getListItemCount_CallBedListView !\n");
    return frameBedList.size();
}

static void obtainListItemData_CallBedListView(ZKListView *pListView,ZKListView::ZKListItem *pListItem, int index) {
    //LOGD(" obtainListItemData_ CallBedListView  !!!\n");
	pListItem->setText(frameBedList[index]["frame_bed"]["full_name"].asString());
	pListItem->findSubItemByID(ID_MAIN_CallBedName)->setText(frameBedList[index]["customer_name"].asString());
}

static void onListItemClick_CallBedListView(ZKListView *pListView, int index, int id) {
//    LOGD(" onListItemClick_ CallBedListView  !!!\n");

    string customerName = frameBedList[index]["customer_name"].asString();
    string toId = frameBedList[index]["bed_device_id"].asString();
    if (customerName == "") {
		Intent* intent = new Intent();
		intent->putExtra(warnText, LANGUAGEMANAGER->getValue("NoCustomer"));
		EASYUICONTEXT->openActivity("warnActivity", intent);
    }
    else if (toId == "") {
		Intent* intent = new Intent();
		intent->putExtra(warnText, LANGUAGEMANAGER->getValue("NoBedDevice"));
		EASYUICONTEXT->openActivity("warnActivity", intent);
    }
    else {
		mCallBebWinPtr->hideWnd();
		Intent* intent = new Intent();
		intent->putExtra(isOutgoing, "true");
		intent->putExtra(audioOnly, "true");
		intent->putExtra(toIdStr, toId);
		intent->putExtra(callName, frameBedList[index]["frame_bed"]["full_name"].asString() + " " + customerName);
		EASYUICONTEXT->openActivity("callActivity", intent);
    }
}

static bool onButtonClick_CallBedCancel(ZKButton *pButton) {
    LOGD(" ButtonClick CallBedCancel !!!\n");
	mCallBebWinPtr->hideWnd();
    return false;
}