diff --git a/include/ctrlm_hal_ble.h b/include/ctrlm_hal_ble.h index f9cb6a14..0f84fc64 100644 --- a/include/ctrlm_hal_ble.h +++ b/include/ctrlm_hal_ble.h @@ -132,6 +132,7 @@ typedef struct { int pairing_code; ctrlm_hal_ble_RcuProperty_t property_updated; ctrlm_hal_ble_rcu_data_t rcu_data; + char ir_fail_reason[CTRLM_MAX_PARAM_STR_LEN]; } ctrlm_hal_ble_RcuStatusData_t; typedef struct { diff --git a/src/ble/ctrlm_ble_controller.cpp b/src/ble/ctrlm_ble_controller.cpp index f1a87c22..864d062c 100644 --- a/src/ble/ctrlm_ble_controller.cpp +++ b/src/ble/ctrlm_ble_controller.cpp @@ -31,6 +31,7 @@ #include "ctrlm_controller.h" #include "ctrlm_hal_ip.h" #include "blercu/bleservices/blercuupgradeservice.h" +#include "ctrlm_telemetry_event.h" #include #include @@ -534,19 +535,30 @@ void ctrlm_obj_controller_ble_t::setSupportedIrdbs(uint8_t vendor_support_bitmas if (irdb == NULL) { XLOGD_ERROR("IRDB interface is NULL!!!"); +#ifdef TELEMETRY_SUPPORT + char t2_buf[256]; + snprintf(t2_buf, sizeof(t2_buf), "[0,0x%02X,\"unknown\",0x00,0]", vendor_support_bitmask); + ctrlm_telemetry_event_t ev(MARKER_IRDB_VENDOR_SET, t2_buf); + ev.event(); +#endif return; } ctrlm_irdb_vendor_info_t rcu_vendor_info{}; rcu_vendor_info.rcu_support_bitmask = vendor_support_bitmask; - if (!irdb->set_vendor(rcu_vendor_info)) { + bool set_result = irdb->set_vendor(rcu_vendor_info); + if (!set_result) { XLOGD_ERROR("Failed to set IRDB vendor info for controller <%s> with bitmask <0x%X>.", ieee_address_get().to_string().c_str(), vendor_support_bitmask); } ctrlm_irdb_vendor_info_t vendor_info{}; + vendor_info.name = "unknown"; + vendor_info.rcu_support_bitmask = 0xFF; + bool supported = false; if (irdb->get_vendor_info(vendor_info)) { - if (isSupportedIrdb(vendor_info)) { + supported = isSupportedIrdb(vendor_info); + if (supported) { XLOGD_INFO("Controller <%s> IRDBs supported bitmask = <0x%X>, which DOES support the loaded IRDB plugin vendor <%s>", ieee_address_get().to_string().c_str(), vendor_support_bitmask, vendor_info.name.c_str()); } else { @@ -557,6 +569,15 @@ void ctrlm_obj_controller_ble_t::setSupportedIrdbs(uint8_t vendor_support_bitmas XLOGD_WARN("Controller <%s> IRDBs supported bitmask = <0x%X>, couldn't retrieve IRDB plugin vendor info.", ieee_address_get().to_string().c_str(), vendor_support_bitmask); } +#ifdef TELEMETRY_SUPPORT + char t2_buf[256]; + snprintf(t2_buf, sizeof(t2_buf), "[%d,0x%02X,\"%s\",0x%02X,%d]", + (int)set_result,vendor_support_bitmask, + vendor_info.name.c_str(), vendor_info.rcu_support_bitmask, + (int)supported); + ctrlm_telemetry_event_t ev(MARKER_IRDB_VENDOR_SET, t2_buf); + ev.event(); +#endif } uint8_t ctrlm_obj_controller_ble_t::getSupportedIrdbs() const { diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 57cdb6da..dbf738ca 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -47,6 +47,7 @@ #include #include #include "ctrlm_rcp_ipc_iarm_thunder.h" +#include "ctrlm_telemetry_event.h" using namespace std; @@ -775,6 +776,16 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size) XLOGD_ERROR("Controller doesn't exist!"); } else if (!controllers_[controller_id]->isSupportedIrdb(dqm->vendor_info)) { XLOGD_ERROR("Unsupported IRDB - not continuing with ir code download!"); +#ifdef TELEMETRY_SUPPORT + char t2_buf[256]; + snprintf(t2_buf, sizeof(t2_buf), "[%d,\"unsupported\",0x%02X,\"%s\",0x%02X]", + (int)CTRLM_IR_STATE_FAILED, + controllers_[controller_id]->getSupportedIrdbs(), + dqm->vendor_info.name.c_str(), + dqm->vendor_info.rcu_support_bitmask); + ctrlm_telemetry_event_t ev(MARKER_IRDB_PROGRAM_RESULT, t2_buf); + ev.event(); +#endif } else { if(dqm->ir_codes) { @@ -1699,6 +1710,37 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_status(void *data, int size) { case CTRLM_HAL_BLE_PROPERTY_IR_STATE: XLOGD_TELEMETRY("BLE remote IR programming state changed to <%s>", ctrlm_ir_state_str(dqm->ir_state)); ir_state_ = dqm->ir_state; +#ifdef TELEMETRY_SUPPORT + { + ctrlm_irdb_vendor_info_t vendor_info{}; + vendor_info.name = "unknown"; + vendor_info.rcu_support_bitmask = 0xFF; + + ctrlm_irdb_interface_t *irdb = ctrlm_main_irdb_get(); + if (irdb) { irdb->get_vendor_info(vendor_info); } + char t2_buf[256]; + if (dqm->ir_state == CTRLM_IR_STATE_COMPLETE || dqm->ir_state == CTRLM_IR_STATE_FAILED) { + ctrlm_controller_id_t controller_id; + uint8_t rcu_bitmask = 0xFF; + if (false == getControllerId(dqm->rcu_data.ieee_address, &controller_id)) { + XLOGD_ERROR("Controller <%s> NOT found in the network!!", + ctrlm_convert_mac_long_to_string(dqm->rcu_data.ieee_address).c_str()); + } else { + auto controller = controllers_[controller_id]; + rcu_bitmask = controller->getSupportedIrdbs(); + } + + snprintf(t2_buf, sizeof(t2_buf), "[%d,\"%s\",0x%02X,\"%s\",0x%02X]", + (int)dqm->ir_state, + dqm->ir_fail_reason, + rcu_bitmask, + vendor_info.name.c_str(), + vendor_info.rcu_support_bitmask); + ctrlm_telemetry_event_t ev(MARKER_IRDB_PROGRAM_RESULT, t2_buf); + ev.event(); + } + } +#endif break; default: { diff --git a/src/ble/ctrlm_ble_rcu_interface.cpp b/src/ble/ctrlm_ble_rcu_interface.cpp index f90cdc67..2af7e88d 100644 --- a/src/ble/ctrlm_ble_rcu_interface.cpp +++ b/src/ble/ctrlm_ble_rcu_interface.cpp @@ -1160,7 +1160,7 @@ bool ctrlm_ble_rcu_interface_t::programIrSignalWaveforms(uint64_t ieee_address, uint8_t vendor) { // lambda invoked when the request returns - auto replyHandler = [this](PendingReply<> *reply) mutable + auto replyHandler = [this, ieee_address](PendingReply<> *reply) mutable { bool success = false; @@ -1173,9 +1173,13 @@ bool ctrlm_ble_rcu_interface_t::programIrSignalWaveforms(uint64_t ieee_address, success = true; } - ctrlm_hal_ble_RcuStatusData_t params; + ctrlm_hal_ble_RcuStatusData_t params = {}; params.property_updated = CTRLM_HAL_BLE_PROPERTY_IR_STATE; params.ir_state = success ? CTRLM_IR_STATE_COMPLETE : CTRLM_IR_STATE_FAILED; + params.rcu_data.ieee_address = ieee_address; + if (!success) { + snprintf(params.ir_fail_reason, CTRLM_MAX_PARAM_STR_LEN, "%s", reply->errorMessage().c_str()); + } m_rcuStatusChangedSlots.invoke(¶ms); }; @@ -1241,9 +1245,10 @@ bool ctrlm_ble_rcu_interface_t::programIrSignalWaveforms(uint64_t ieee_address, success = false; } - ctrlm_hal_ble_RcuStatusData_t params; + ctrlm_hal_ble_RcuStatusData_t params = {}; params.property_updated = CTRLM_HAL_BLE_PROPERTY_IR_STATE; params.ir_state = success ? CTRLM_IR_STATE_WAITING : CTRLM_IR_STATE_FAILED; + params.rcu_data.ieee_address = ieee_address; m_rcuStatusChangedSlots.invoke(¶ms); return success; @@ -1252,7 +1257,7 @@ bool ctrlm_ble_rcu_interface_t::programIrSignalWaveforms(uint64_t ieee_address, bool ctrlm_ble_rcu_interface_t::eraseIrSignals(uint64_t ieee_address) { // lambda invoked when the request returns - auto replyHandler = [this](PendingReply<> *reply) mutable + auto replyHandler = [this, ieee_address](PendingReply<> *reply) mutable { bool success = false; @@ -1265,9 +1270,13 @@ bool ctrlm_ble_rcu_interface_t::eraseIrSignals(uint64_t ieee_address) success = true; } - ctrlm_hal_ble_RcuStatusData_t params; + ctrlm_hal_ble_RcuStatusData_t params = {}; params.property_updated = CTRLM_HAL_BLE_PROPERTY_IR_STATE; params.ir_state = success ? CTRLM_IR_STATE_COMPLETE : CTRLM_IR_STATE_FAILED; + params.rcu_data.ieee_address = ieee_address; + if (!success) { + snprintf(params.ir_fail_reason, CTRLM_MAX_PARAM_STR_LEN, "%s", reply->errorMessage().c_str()); + } m_rcuStatusChangedSlots.invoke(¶ms); }; @@ -1289,9 +1298,10 @@ bool ctrlm_ble_rcu_interface_t::eraseIrSignals(uint64_t ieee_address) success = false; } - ctrlm_hal_ble_RcuStatusData_t params; + ctrlm_hal_ble_RcuStatusData_t params = {}; params.property_updated = CTRLM_HAL_BLE_PROPERTY_IR_STATE; params.ir_state = success ? CTRLM_IR_STATE_WAITING : CTRLM_IR_STATE_FAILED; + params.rcu_data.ieee_address = ieee_address; m_rcuStatusChangedSlots.invoke(¶ms); return success; diff --git a/src/irdb/ctrlm_irdb_interface.cpp b/src/irdb/ctrlm_irdb_interface.cpp index 01fa6588..bab8f9a6 100644 --- a/src/irdb/ctrlm_irdb_interface.cpp +++ b/src/irdb/ctrlm_irdb_interface.cpp @@ -21,6 +21,7 @@ #include "ctrlm_network.h" #include "ctrlm_log.h" #include "ctrlm_irdb_stub.h" +#include "ctrlm_telemetry_event.h" #include "ctrlm_ipc_iarm.h" #include "ctrlm_irdb_ipc_iarm_thunder.h" @@ -41,10 +42,36 @@ #include #include +#include #include +#include using namespace std; +typedef enum { + CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID = 0, + CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, + CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, + CTRLM_IRDB_AUTOLOOKUP_SOURCE_UNKNOWN +} ctrlm_irdb_autolookup_source_t; + +typedef enum { + CTRLM_IRDB_AUTOLOOKUP_RESULT_SUCCESS = 0, + CTRLM_IRDB_AUTOLOOKUP_RESULT_NULL, + CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_SOURCE_DATA, + CTRLM_IRDB_AUTOLOOKUP_RESULT_FAILED, + CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_CODES_FOR_SOURCE, + CTRLM_IRDB_AUTOLOOKUP_RESULT_DEV_TYPE_INVALID, + CTRLM_IRDB_AUTOLOOKUP_RESULT_UNKNOWN, +} ctrlm_irdb_autolookup_result_t; + +class ctrlm_irdb_t2_autolookup_entry_t { +public: + ctrlm_irdb_t2_autolookup_entry_t(int p, ctrlm_irdb_autolookup_source_t s, ctrlm_irdb_autolookup_result_t r): port(p), source(s), result(r) {} + int port = -1; + ctrlm_irdb_autolookup_source_t source = CTRLM_IRDB_AUTOLOOKUP_SOURCE_UNKNOWN; + ctrlm_irdb_autolookup_result_t result = CTRLM_IRDB_AUTOLOOKUP_RESULT_UNKNOWN; +}; static ctrlm_irdb_interface_t *_instance = NULL; @@ -420,6 +447,13 @@ bool comp_autolookup_ranked_list (ctrlm_irdb_autolookup_entry_ranked_t i, ctrlm_ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_list_by_type_t &codes) { std::unique_lock guard(m_mutex); bool ret = false; + std::vector t2_info; + + // Retrieve vendor info now while mutex is held (avoids recursive lock via get_vendor_info()) + ctrlm_irdb_vendor_info_t t2_vendor_info{}; + if (g_irdb.pluginGetVendorInfo) { + (*g_irdb.pluginGetVendorInfo)(t2_vendor_info); + } #if defined(CTRLM_THUNDER) if(m_platform_tv == false) { @@ -436,20 +470,26 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ if(type != CTRLM_IRDB_DEV_TYPE_INVALID) { codes[type].insert(codes[type].end(), ir_codes.begin(), ir_codes.end()); ret = true; + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_SUCCESS); } else { XLOGD_ERROR("edid dev type invalid"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_DEV_TYPE_INVALID); } } else { XLOGD_ERROR("no codes for edid data"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_CODES_FOR_SOURCE); } } else { XLOGD_ERROR("Failed getting codes by edid"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_FAILED); } } else { XLOGD_ERROR("No EDID data"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_SOURCE_DATA); } } else { XLOGD_ERROR("display_settings is NULL"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_EDID, CTRLM_IRDB_AUTOLOOKUP_RESULT_NULL); } if(g_irdb.cec_source) { // Check CEC data @@ -465,21 +505,27 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ if(type != CTRLM_IRDB_DEV_TYPE_INVALID) { codes[type].insert(codes[type].end(), ir_codes.begin(), ir_codes.end()); ret = true; + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_SUCCESS); } else { XLOGD_ERROR("cec dev type invalid"); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_DEV_TYPE_INVALID); } } else { XLOGD_WARN("no code for cec device <%s>", itr.osd.c_str()); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_CODES_FOR_SOURCE); } } else { XLOGD_WARN("Failed to get codes for cec device <%s>", itr.osd.c_str()); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_FAILED); } } } else { XLOGD_ERROR("No CEC device data"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_SOURCE_DATA); } } else { XLOGD_ERROR("cec is NULL"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NULL); } } else { if(g_irdb.av_input) { @@ -495,21 +541,27 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ if(type != CTRLM_IRDB_DEV_TYPE_INVALID) { codes[type].insert(codes[type].end(), ir_codes.begin(), ir_codes.end()); ret = true; + t2_info.emplace_back(itr.first, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_SUCCESS); } else { XLOGD_ERROR("port %d infoframe dev type invalid", itr.first); + t2_info.emplace_back(itr.first, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_DEV_TYPE_INVALID); } } else { XLOGD_WARN("no code for port %d infoframe", itr.first); + t2_info.emplace_back(itr.first, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_CODES_FOR_SOURCE); } } else { XLOGD_WARN("Failed to get codes for port %d infoframe", itr.first); + t2_info.emplace_back(itr.first, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_FAILED); } } else { XLOGD_WARN("no infoframe for port %d", itr.first); + t2_info.emplace_back(itr.first, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_SOURCE_DATA); } } } else { XLOGD_ERROR("hdmi is NULL"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_INFOFRAME, CTRLM_IRDB_AUTOLOOKUP_RESULT_NULL); } if(g_irdb.cec_sink) { // Check CEC data @@ -524,21 +576,27 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ if(type != CTRLM_IRDB_DEV_TYPE_INVALID) { codes[type].insert(codes[type].end(), ir_codes.begin(), ir_codes.end()); ret = true; + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_SUCCESS); } else { XLOGD_ERROR("cec dev type invalid"); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_DEV_TYPE_INVALID); } } else { XLOGD_WARN("no code for cec device <%s>", itr.osd.c_str()); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_CODES_FOR_SOURCE); } } else { XLOGD_WARN("Failed to get codes for cec device <%s>", itr.osd.c_str()); + t2_info.emplace_back(itr.port, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_FAILED); } } } else { XLOGD_ERROR("No CEC device data"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NO_SOURCE_DATA); } } else { - XLOGD_ERROR("cec_sink is NULL"); + XLOGD_ERROR("cec is NULL"); + t2_info.emplace_back(-1, CTRLM_IRDB_AUTOLOOKUP_SOURCE_CEC, CTRLM_IRDB_AUTOLOOKUP_RESULT_NULL); } } #endif @@ -557,6 +615,30 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ codes[CTRLM_IRDB_DEV_TYPE_AVR].erase( unique( codes[CTRLM_IRDB_DEV_TYPE_AVR].begin(), codes[CTRLM_IRDB_DEV_TYPE_AVR].end() ), codes[CTRLM_IRDB_DEV_TYPE_AVR].end() ); } +#ifdef TELEMETRY_SUPPORT + size_t tv_count = codes.count(CTRLM_IRDB_DEV_TYPE_TV) ? codes.at(CTRLM_IRDB_DEV_TYPE_TV).size() : 0; + size_t avr_count = codes.count(CTRLM_IRDB_DEV_TYPE_AVR) ? codes.at(CTRLM_IRDB_DEV_TYPE_AVR).size() : 0; + std::stringstream ss; + bool first = true; + for (const auto &entry : t2_info) { + if (!first) { + ss << ","; + } + ss << entry.port << "," << static_cast(entry.source) << "," << static_cast(entry.result); + first = false; + } + std::string results = ss.str(); + ss.str(""); + ss << "[\"" << t2_vendor_info.name << "\"" + << ",0x" << std::hex << std::setfill('0') << std::setw(2) << (int)t2_vendor_info.rcu_support_bitmask + << "," << std::dec << (int)m_platform_tv + << "," << tv_count + << "," << avr_count + << "," << (results.empty() ? "\"\"" : results) << "]"; + ctrlm_telemetry_event_t ev(MARKER_IRDB_AUTOLOOKUP_RESULT, ss.str()); + ev.event(); +#endif + return(ret); } diff --git a/src/irdb/ipc/ctrlm_irdb_ipc_iarm_thunder.cpp b/src/irdb/ipc/ctrlm_irdb_ipc_iarm_thunder.cpp index 48b7c29a..e58f7a64 100644 --- a/src/irdb/ipc/ctrlm_irdb_ipc_iarm_thunder.cpp +++ b/src/irdb/ipc/ctrlm_irdb_ipc_iarm_thunder.cpp @@ -23,6 +23,7 @@ #include "ctrlm_log.h" #include "json_config.h" #include "ctrlm_utils.h" +#include "ctrlm_telemetry_event.h" namespace { constexpr char const* NET_TYPE = "netType"; @@ -152,6 +153,17 @@ IARM_Result_t ctrlm_irdb_ipc_iarm_thunder_t::get_manufacturers(void *arg) { } } +#ifdef TELEMETRY_SUPPORT + ctrlm_irdb_vendor_info_t vendor_info{}; + if (irdb) { + irdb->get_vendor_info(vendor_info); + } + char t2_buf[128]; + snprintf(t2_buf, sizeof(t2_buf), "[\"%s\",0x%02X,\"%s\",%d]", vendor_info.name.c_str(), vendor_info.rcu_support_bitmask, CTRLM_MAIN_IARM_CALL_IR_MANUFACTURERS, (int)success); + ctrlm_telemetry_event_t ev(MARKER_IRDB_MANUAL_RESULT, t2_buf); + ev.event(); +#endif + // Assemble the return json_object_set_new(ret, SUCCESS, json_boolean(success)); if(success) { @@ -226,6 +238,17 @@ IARM_Result_t ctrlm_irdb_ipc_iarm_thunder_t::get_models(void *arg) { } } +#ifdef TELEMETRY_SUPPORT + ctrlm_irdb_vendor_info_t vendor_info{}; + if(irdb) { + irdb->get_vendor_info(vendor_info); + } + char t2_buf[128]; + snprintf(t2_buf, sizeof(t2_buf), "[\"%s\",0x%02X,\"%s\",%d]", vendor_info.name.c_str(), vendor_info.rcu_support_bitmask, CTRLM_MAIN_IARM_CALL_IR_MODELS, (int)success); + ctrlm_telemetry_event_t ev(MARKER_IRDB_MANUAL_RESULT, t2_buf); + ev.event(); +#endif + // Assemble the return json_object_set_new(ret, SUCCESS, json_boolean(success)); if(success) { @@ -366,6 +389,17 @@ IARM_Result_t ctrlm_irdb_ipc_iarm_thunder_t::get_irdb_entry_ids(void *arg) { } } +#ifdef TELEMETRY_SUPPORT + ctrlm_irdb_vendor_info_t vendor_info{}; + if (irdb) { + irdb->get_vendor_info(vendor_info); + } + char t2_buf[128]; + snprintf(t2_buf, sizeof(t2_buf), "[\"%s\",0x%02X,\"%s\",%d]", vendor_info.name.c_str(), vendor_info.rcu_support_bitmask, CTRLM_MAIN_IARM_CALL_IR_CODES, (int)success); + ctrlm_telemetry_event_t ev(MARKER_IRDB_MANUAL_RESULT, t2_buf); + ev.event(); +#endif + // Assemble the return json_object_set_new(ret, SUCCESS, json_boolean(success)); if(success) { diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 23c0f775..28e2595b 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -125,4 +125,18 @@ // End Voice Markers // +// +// IRDB Markers +// + +// All _accum markers are aggregated by the T2 platform within each reporting window. +#define MARKER_IRDB_AUTOLOOKUP_RESULT "ctrlm.irdb.autolookup.result_accum" // format: ,,,,, +#define MARKER_IRDB_MANUAL_RESULT "ctrlm.irdb.manual.result_accum" // format: ,,, +#define MARKER_IRDB_PROGRAM_RESULT "ctrlm.irdb.program.result_accum" // format: ,,,, +#define MARKER_IRDB_VENDOR_SET "ctrlm.irdb.vendor_set_accum" // format: ,,,, + +// +// End IRDB Markers +// + #endif diff --git a/src/thunder/plugins/ctrlm_thunder_plugin_display_settings.cpp b/src/thunder/plugins/ctrlm_thunder_plugin_display_settings.cpp index 662af928..b11001e6 100644 --- a/src/thunder/plugins/ctrlm_thunder_plugin_display_settings.cpp +++ b/src/thunder/plugins/ctrlm_thunder_plugin_display_settings.cpp @@ -118,7 +118,7 @@ bool ctrlm_thunder_plugin_display_settings_t::_get_edid() { } } ret = true; - XLOGD_DEBUG("EDID data <%d> bytes: \n<%s>", edid_size, ss.str().c_str()); + XLOGD_INFO("EDID data <%d> bytes: \n<%s>", edid_size, ss.str().c_str()); } else { XLOGD_ERROR("Failed to decode EDID base64!"); }