def on_request_control(self, item, data, timeout):
""" MsgControlReq """
logger.debug(self._tag + "===> on_request_control")
convert_control_item_dict = {
'ENGINE': tbox_pb2.ENGINE,
'AIR_CONDITION_CTRL': tbox_pb2.AIR_CONDITION_CTRL,
'LOCK': tbox_pb2.LOCK,
'FIND_VEHICLE': tbox_pb2.FIND_VEHICLE,
}
config_item = convert_control_item_dict[item]
self._result = False
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.CONTROL_CMD)
# remote_control_request
publish_msg.remote_control_cmd.cmd = config_item
self.__set_control_item(publish_msg, config_item, data)
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX, publish_msg.SerializeToString())
MqttDump.dump(publish_msg, logger.info)
# wait_event
self._event.wait(int(timeout))
if not self._event.isSet() or not self._result:
logger.error(self._tag + "Exception on remote_control_request: Timeout to wait event")
self._event.clear()
return self._result
def on_push_message(self, timeout):
logger.info(self._tag + "===> on_push_message")
self._result = False
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.PUSH_MESSAGE)
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX, publish_msg.SerializeToString())
MqttDump.dump(publish_msg, logger.info)
def on_create(self):
logger.debug(self._tag + "on_create called")
# MsgTop
self._msgtop = tbox_pb2.MsgTop()
# MQTT onCreate
self._mqttc = mqtt.Client()
encryption = MQTT_MAJOR_ENCRYPTION if self._server == MQTT_MAJOR_SERVER else MQTT_MINOR_ENCRYPTION
if encryption != '':
try:
self._mqttc.tls_set(encryption)
self._mqttc.tls_insecure_set(True)
except Exception, e:
raise MqttCommError("Exception on set MQTT TLS: " + str(e) + '(' + encryption + ')')
def __on_response_heartbeat(self, client, userdata, msgtop):
""" MsgHeartBeatResp """
logger.info(self._tag + "===> on_response_heartbeat")
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self._msg_id, tbox_pb2.HEARTBEAT_RESP)
# heartbeat_response
publish_msg.heart_beat_response.ack.status = True
publish_msg.heart_beat_response.ack.code = "Succeed to response heartbeat"
# publish
client.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
MqttDump.dump(publish_msg)
def __on_response_ota_checksum(self, client, userdata, msgtop):
""" MsgOtaCmdCheckSumResponse """
logger.console(self._tag + "===> on_response_ota_checksum")
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, msgtop.message_head.message_id, tbox_pb2.OTA_CHECKSUM_RESP)
# login_response
publish_msg.ota_cmd_check_response.ack.status = True
publish_msg.ota_cmd_check_response.ack.code = "Succeed to response ota checksum"
publish_msg.ota_cmd_check_response.check_sum_result = True if self._ota_checksum == msgtop.ota_cmd_check_request.check_sum_code else False
publish_msg.ota_cmd_check_response.ota_task_id = msgtop.ota_cmd_check_request.ota_task_id
# publish
client.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
def __on_response_config_query(self, client, userdata, msgtop):
""" MsgConfQueryResp """
logger.info(self._tag + "===> on_response_config_query")
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self._msg_id, tbox_pb2.CONFIG_QUERY_RESP)
# config_query_response
publish_msg.config_query_response.ack.status = True
publish_msg.config_query_response.ack.code = "Succeed to response config query"
publish_msg.config_query_response.qconfig_data.CopyFrom(self._msgtop.config_query_response.qconfig_data)
# publish
client.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
MqttDump.dump(publish_msg)
def on_request_diagnosis(self, timeout):
logger.info(self._tag + "===> on_request_diagnosis")
self._result = False
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.DIAGNOSIS_REQ)
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX, publish_msg.SerializeToString())
MqttDump.dump(publish_msg, logger.info)
# wait_event
self._event.wait(int(timeout))
if not self._event.isSet() or not self._result:
logger.error(self._tag + "Exception on remote_diagnosis_request: Timeout to wait event")
self._event.clear()
return self._result
def __handle_topic_business(self, client, userdata, msg):
logger.console(self._tag + "__handle_topic_business called")
msgtop = tbox_pb2.MsgTop()
msgtop.ParseFromString(msg.payload)
if self.__is_valid_device(msgtop):
# set parameter
if not self._is_connected:
self._protocol_version = msgtop.message_head.protocol_version
self._equipment_id_type = msgtop.message_head.equipment_id_type
self._msg_id = msgtop.message_head.message_id
self._token = "token-" + self._expected_device
self._is_connected = True
MqttDump.dump(msgtop)
handle = self._handle_business_dict.get(msgtop.message_head.msg_type, None)
if handle is not None:
handle(client, userdata, msgtop)
def __handle_topic_report(self, client, userdata, msg):
logger.debug(self._tag + "==> handle_topic_report")
msgtop = tbox_pb2.MsgTop()
msgtop.ParseFromString(msg.payload)
if self.__is_valid_device(msgtop):
# set parameter
if not self._is_connected:
self._protocol_version = msgtop.message_head.protocol_version
self._did_type = msgtop.message_head.did_type
self._msg_id = msgtop.message_head.message_id
self._token = msgtop.message_head.token
self._task_id = msgtop.message_head.task_id
self._is_connected = True
MqttDump.dump(msgtop)
handle = self._handle_report_dict.get(msgtop.message_head.msg_type, None)
if handle is not None:
handle(client, userdata, msgtop)
def on_request_ota_cmd(self, ver, addr, checksum, timeout):
""" MsgOtaCmd """
logger.debug(self._tag + "===> on_request_ota_cmd")
# initial ota_result.result
self._msgtop.ota_result.Clear()
self._msgtop.ota_result.result = tbox_pb2.OTA_IN_PROCESS
self._ota_checksum = checksum
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.OTA_CMD_REQ)
# remote_ota_request
publish_msg.ota_cmd.update_target_version = ver
publish_msg.ota_cmd.upgrade_file_download_addr = addr
publish_msg.ota_cmd.ota_task_id = 'task-' + str(publish_msg.message_head.msg_c_time) + ''.join(str(random.choice(range(10))) for _ in range(5))
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
MqttDump.dump(publish_msg, logger.info)
def on_request_remote_config(self, item, data, timeout):
"""
"""
logger.info(self._tag + "on_request_remote_config called")
convert_config_item_dict = {
'MQTT_SERVER_ADDR': tbox_pb2.MQTT_SERVER_ADDR,
'MQTT_SERVER_TOPIC': tbox_pb2.MQTT_SERVER_TOPIC,
'MQTT_KEY_BUSINESS_SERVER_ADDR': tbox_pb2.MQTT_KEY_BUSINESS_SERVER_ADDR,
'MQTT_KEY_BUSINESS_SERVER_TOPIC': tbox_pb2.MQTT_KEY_BUSINESS_SERVER_TOPIC,
'ECALL_NUMBER': tbox_pb2.ECALL_NUMBER,
'BCALL_NUMBER': tbox_pb2.BCALL_NUMBER,
'ICALL_NUMBER': tbox_pb2.ICALL_NUMBER,
'ECALL_ENABLE': tbox_pb2.ECALL_ENABLE,
'BCALL_ENABLE': tbox_pb2.BCALL_ENABLE,
'ICALL_ENABLE': tbox_pb2.ICALL_ENABLE,
'SMS_GATE_NUMBER_UPLOAD': tbox_pb2.SMS_GATE_NUMBER_UPLOAD,
'SMS_GATE_NUMBER_DOWNLOAD': tbox_pb2.SMS_GATE_NUMBER_DOWNLOAD,
'DATAMINING_UPLOAD_FREQUENCY': tbox_pb2.DATAMINING_UPLOAD_FREQUENCY,
'VEHICLE_STATUS_UPLOAD_FREQUENCY': tbox_pb2.VEHICLE_STATUS_UPLOAD_FREQUENCY,
'IGNITION_BLOWOUT_UPLOAD_ENABLE': tbox_pb2.IGNITION_BLOWOUT_UPLOAD_ENABLE,
'UPLOAD_ALERT_ENABLE': tbox_pb2.UPLOAD_ALERT_ENABLE,
'DATAMING_ENABLE': tbox_pb2.DATAMING_ENABLE,
'SVT_ENABLE': tbox_pb2.SVT_ENABLE,
'ELETRONIC_DEFENSE_ENABLE': tbox_pb2.ELETRONIC_DEFENSE_ENABLE,
'ABNORMAL_MOVE_THRESHOLD_VALUE': tbox_pb2.ABNORMAL_MOVE_THRESHOLD_VALUE,
}
config_item = convert_config_item_dict[item]
self._result = False
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.REMOTE_CONFIG_REQUEST)
# remote_config_request
publish_msg.remote_config_request.config_items.append(config_item)
self.__set_remote_config_item(publish_msg, config_item, data)
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX, publish_msg.SerializeToString())
MqttDump.dump(publish_msg, logger.info)
# wait_event
self._event.wait(int(timeout))
if not self._event.isSet() or not self._result:
logger.error(self._tag + "Exception on remote_config_request: Timeout to wait event")
self._event.clear()
return self._result
def __on_response_login(self, client, userdata, msgtop):
""" MsgLoginResp """
logger.info(self._tag + "===> on_response_login")
# set parameter
if not self._is_connected:
self._protocol_version = msgtop.message_head.protocol_version
self._did_type = msgtop.message_head.did_type
self._msg_id = msgtop.message_head.message_id
self._token = "token-" + self._expected_device
self._is_connected = True
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self._msg_id, tbox_pb2.LOGIN_RESP)
# login_response
publish_msg.login_response.ack.status = True
publish_msg.login_response.ack.code = "Succeed to login"
publish_msg.login_response.token = self._token
# publish
client.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
MqttDump.dump(publish_msg)
def __on_response_login(self, client, userdata, msgtop):
""" on_response_login """
logger.console(self._tag + "on_response_login called")
# set parameter
if not self._is_connected:
self._protocol_version = msgtop.message_head.protocol_version
self._equipment_id_type = msgtop.message_head.equipment_id_type
self._msg_id = msgtop.message_head.message_id
self._token = "token-" + self._expected_device
self._is_connected = True
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self._msg_id, tbox_pb2.LOGIN_RESPONSE)
# login_response
publish_msg.login_response.ack_code.ack_code = tbox_pb2.SUCCESS
publish_msg.login_response.ack_code.code_desp = "Succeed to login"
publish_msg.login_response.token = self._token
# publish
client.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX,
publish_msg.SerializeToString())
logger.console(self._tag + "on_response_login done")
def on_request_config(self, item, data, timeout):
""" MsgConfReq """
logger.debug(self._tag + "===> on_request_config")
config_item_req_dict = {
'MQTT_SERVER_ADDR_REQ': self._on_request_mqtt_server_addr,
'MQTT_SERVER_TOPIC_REQ': self._on_request_mqtt_server_topic,
'MQTT_KEY_BUSINESS_SERVER_ADDR_REQ': self._on_request_mqtt_key_business_server_addr,
'MQTT_KEY_BUSINESS_SERVER_TOPIC_REQ': self._on_request_mqtt_key_business_server_topic,
'ECALL_NUMBER_REQ': self._on_request_ecall_number,
'BCALL_NUMBER_REQ': self._on_request_bcall_number,
'ICALL_NUMBER_REQ': self._on_request_icall_number,
'ECALL_ENABLE_REQ': self._on_request_ecall_enable,
'BCALL_ENABLE_REQ': self._on_request_bcall_enable,
'ICALL_ENABLE_REQ': self._on_request_icall_enable,
'SMS_GATE_NUMBER_UPLOAD_REQ': self._on_request_sms_gate_number_upload,
'SMS_GATE_NUMBER_DOWNLOAD_REQ': self._on_request_sms_gate_number_download,
'DATAMINING_UPLOAD_FREQUENCY_REQ': self._on_request_datamining_upload_freq,
'VEHICLE_STATUS_UPLOAD_FREQUENCY_REQ': self._on_request_vehicle_status_upload_freq,
'IGNITION_BLOWOUT_UPLOAD_ENABLE_REQ': self._on_request_ignition_blowout_upload_enable,
'UPLOAD_ALERT_ENABLE_REQ': self._on_request_upload_alert_enable,
'DATAMING_ENABLE_REQ': self._on_request_datamining_enable,
'SVT_ENABLE_REQ': self._on_request_svt_enable,
'ELETRONIC_DEFENSE_ENABLE_REQ': self._on_request_eletronic_defense_enable,
'ABNORMAL_MOVE_THRESHOLD_VALUE_REQ': self._on_request_abnormal_move_threshold_value,
'TRACKING_DATA_FREQUENCY_REQ': self._on_request_tracking_data_freq,
}
self._result = False
publish_msg = tbox_pb2.MsgTop()
# message_head
self.__fill_message_head(publish_msg, self.__inc_msg_id(), tbox_pb2.CONFIG_REQ)
# remote_config_request
config_item_req_dict[item](publish_msg, data)
# publish
self._mqttc.publish(MQTT_DEVICE_TOPIC_PREFIX + self._expected_device + MQTT_DEVICE_TOPIC_SUFFIX, publish_msg.SerializeToString())
logging_print("===========Publish Message===========")
MqttDump.dump(publish_msg, logging_print)
def on_parse(self, msg):
msgtop = tbox_pb2.MsgTop()
msgtop.ParseFromString(msg)
ParseDump.dump(msgtop)
