diff --git a/src/attributes/ctrlm_attr_general.cpp b/src/attributes/ctrlm_attr_general.cpp index 80a6edb9..7eb29bce 100644 --- a/src/attributes/ctrlm_attr_general.cpp +++ b/src/attributes/ctrlm_attr_general.cpp @@ -87,7 +87,9 @@ bool ctrlm_string_db_attr_t::write_db(ctrlm_db_ctx_t ctx) { bool ret = false; ctrlm_db_blob_t blob(this->get_key(), this->get_table()); - if(blob.from_string(this->value)) { + if (this->value.empty()) { + XLOGD_DEBUG("value is empty for db key <%s>", this->get_name().c_str()); + } else if(blob.from_string(this->value)) { if(blob.write_db(ctx)) { ret = true; XLOGD_DEBUG("%s written to database: %s", this->get_name().c_str(), this->to_string().c_str()); diff --git a/src/ble/ctrlm_ble_controller.cpp b/src/ble/ctrlm_ble_controller.cpp index f91b99c7..7422a939 100644 --- a/src/ble/ctrlm_ble_controller.cpp +++ b/src/ble/ctrlm_ble_controller.cpp @@ -692,8 +692,10 @@ void ctrlm_obj_controller_ble_t::print_status() { } else { XLOGD_INFO("IR Database Support : N/A"); } - XLOGD_INFO("Programmed TV IRDB Code : %s", irdb_entry_id_name_tv_->to_string().c_str()); - XLOGD_INFO("Programmed AVR IRDB Code : %s", irdb_entry_id_name_avr_->to_string().c_str()); + XLOGD_INFO("Programmed TV IRDB Code : %s (Manufacturer = %s, Model = %s)", + irdb_entry_id_name_tv_->to_string().c_str(), irdb_manufacturer_tv_->to_string().c_str(), irdb_model_tv_->to_string().c_str()); + XLOGD_INFO("Programmed AVR IRDB Code : %s (Manufacturer = %s, Model = %s)", + irdb_entry_id_name_avr_->to_string().c_str(), irdb_manufacturer_avr_->to_string().c_str(), irdb_model_avr_->to_string().c_str()); XLOGD_INFO(""); voice_metrics_->print(__FUNCTION__); XLOGD_WARN("------------------------------------------------------------"); diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index a0f37652..1709490b 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -806,7 +806,7 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size) } else { ctrlm_controller_id_t controller_id = dqm->controller_id; if (!is_managed_by_network(controller_id)) { - XLOGD_ERROR("Controller %d is not managed by the %s network", controller_id, name_get()); + XLOGD_WARN("Controller %d is not managed by the %s network", controller_id, name_get()); } else if (!controller_exists(controller_id)) { XLOGD_ERROR("Controller doesn't exist!"); } else if (!controllers_[controller_id]->isSupportedIrdb(dqm->vendor_info)) { @@ -839,7 +839,7 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size) std::map> ir_codes; // First add IR Codes to the IR RF Database (this contains all of the logic for maintaining TV vs AVR codes) - ir_rf_database_.add_irdb_codes(dqm->ir_codes, dqm->vendor_info.rcu_support_bitmask, dqm->vendor_info.name); + ir_rf_database_.add_irdb_codes(dqm->ir_codes, dqm->manufacturer, dqm->model, dqm->vendor_info.rcu_support_bitmask, dqm->vendor_info.name); XLOGD_INFO("\n%s", this->ir_rf_database_.to_string(false).c_str()); XLOGD_DEBUG("\n%s", this->ir_rf_database_.to_string(true).c_str()); // Now get the IR codes for the BLE IR slots @@ -864,7 +864,8 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size) success = true; controllers_[controller_id]->irdb_entry_id_name_set(CTRLM_IRDB_DEV_TYPE_TV, ir_rf_database_.get_tv_ir_code_id()); controllers_[controller_id]->irdb_entry_id_name_set(CTRLM_IRDB_DEV_TYPE_AVR, ir_rf_database_.get_avr_ir_code_id()); - XLOGD_INFO("irdb_entry_id_name = <%s>", dqm->ir_codes->id.c_str()); + controllers_[controller_id]->irdb_manufacturer_model_set(dqm->ir_codes->type, dqm->manufacturer, dqm->model); + XLOGD_INFO("irdb_entry_id_name = <%s>, manufacturer/model = <%s / %s>", dqm->ir_codes->id.c_str(), dqm->manufacturer.c_str(), dqm->model.c_str()); } } // Store the IR codes in the database diff --git a/src/ctrlm_controller.cpp b/src/ctrlm_controller.cpp index 0e7b175e..8ad53d2e 100644 --- a/src/ctrlm_controller.cpp +++ b/src/ctrlm_controller.cpp @@ -40,6 +40,10 @@ ctrlm_obj_controller_t::ctrlm_obj_controller_t(ctrlm_controller_id_t controller_ last_key_code_(std::make_shared("Last Keypress Code", CTRLM_KEY_CODE_INVALID, &network, controller_id, "last_key_code")), irdb_entry_id_name_tv_(std::make_shared("TV IRDB Code", "0", &network, controller_id, "irdb_entry_id_name_tv")), irdb_entry_id_name_avr_(std::make_shared("AVR IRDB Code", "0", &network, controller_id, "irdb_entry_id_name_avr")), + irdb_manufacturer_tv_(std::make_shared("TV IRDB Manufacturer", "", &network, controller_id, "irdb_manufacturer_tv")), + irdb_model_tv_(std::make_shared("TV IRDB Model", "", &network, controller_id, "irdb_model_tv")), + irdb_manufacturer_avr_(std::make_shared("AVR IRDB Manufacturer", "", &network, controller_id, "irdb_manufacturer_avr")), + irdb_model_avr_(std::make_shared("AVR IRDB Model", "", &network, controller_id, "irdb_model_avr")), voice_metrics_(std::make_shared(&network, controller_id)), ota_failure_cnt_from_last_success_(std::make_shared("OTA Failure Count From Last Success", 0, &network, controller_id, "ota_failure_cnt_last_success")) { @@ -69,6 +73,10 @@ void ctrlm_obj_controller_t::db_load() { ctrlm_db_attr_read(last_key_code_.get()); ctrlm_db_attr_read(irdb_entry_id_name_tv_.get()); ctrlm_db_attr_read(irdb_entry_id_name_avr_.get()); + ctrlm_db_attr_read(irdb_manufacturer_tv_.get()); + ctrlm_db_attr_read(irdb_model_tv_.get()); + ctrlm_db_attr_read(irdb_manufacturer_avr_.get()); + ctrlm_db_attr_read(irdb_model_avr_.get()); ctrlm_db_attr_read(voice_metrics_.get()); ctrlm_db_attr_read(ota_failure_cnt_from_last_success_.get()); @@ -85,6 +93,10 @@ void ctrlm_obj_controller_t::db_store() { ctrlm_db_attr_write(last_key_code_); ctrlm_db_attr_write(irdb_entry_id_name_tv_); ctrlm_db_attr_write(irdb_entry_id_name_avr_); + ctrlm_db_attr_write(irdb_manufacturer_tv_); + ctrlm_db_attr_write(irdb_model_tv_); + ctrlm_db_attr_write(irdb_manufacturer_avr_); + ctrlm_db_attr_write(irdb_model_avr_); ctrlm_db_attr_write(voice_metrics_); } @@ -208,6 +220,34 @@ void ctrlm_obj_controller_t::irdb_entry_id_name_set(ctrlm_irdb_dev_type_t type, } } +void ctrlm_obj_controller_t::irdb_manufacturer_model_set(ctrlm_irdb_dev_type_t type, const std::string &manufacturer, const std::string &model) { + switch(type) { + case CTRLM_IRDB_DEV_TYPE_TV: + if (irdb_manufacturer_tv_->to_string() != manufacturer) { + irdb_manufacturer_tv_->set_value(manufacturer); + ctrlm_db_attr_write(irdb_manufacturer_tv_); + } + if (irdb_model_tv_->to_string() != model) { + irdb_model_tv_->set_value(model); + ctrlm_db_attr_write(irdb_model_tv_); + } + break; + case CTRLM_IRDB_DEV_TYPE_AVR: + if (irdb_manufacturer_avr_->to_string() != manufacturer) { + irdb_manufacturer_avr_->set_value(manufacturer); + ctrlm_db_attr_write(irdb_manufacturer_avr_); + } + if (irdb_model_avr_->to_string() != model) { + irdb_model_avr_->set_value(model); + ctrlm_db_attr_write(irdb_model_avr_); + } + break; + default: + XLOGD_WARN("Invalid type <%d>", type); + break; + } +} + std::string ctrlm_obj_controller_t::get_irdb_entry_id_name_tv() const { return irdb_entry_id_name_tv_->to_string(); } @@ -427,6 +467,10 @@ void ctrlm_obj_controller_t::update_controller_id_and_db_entry(std::string db_na last_key_code_->set_table(new_table); irdb_entry_id_name_tv_->set_table(new_table); irdb_entry_id_name_avr_->set_table(new_table); + irdb_manufacturer_tv_->set_table(new_table); + irdb_model_tv_->set_table(new_table); + irdb_manufacturer_avr_->set_table(new_table); + irdb_model_avr_->set_table(new_table); voice_metrics_->set_table(new_table); ota_failure_cnt_from_last_success_->set_table(new_table); } diff --git a/src/ctrlm_controller.h b/src/ctrlm_controller.h index ae9b800b..429f3995 100644 --- a/src/ctrlm_controller.h +++ b/src/ctrlm_controller.h @@ -55,6 +55,7 @@ class ctrlm_obj_controller_t void send_to(unsigned long delay, unsigned long length, char *data); virtual void irdb_entry_id_name_set(ctrlm_irdb_dev_type_t type, const std::string &irdb_ir_entry_id); + virtual void irdb_manufacturer_model_set(ctrlm_irdb_dev_type_t type, const std::string &manufacturer, const std::string &model); std::string get_irdb_entry_id_name_tv() const; std::string get_irdb_entry_id_name_avr() const; @@ -125,6 +126,10 @@ class ctrlm_obj_controller_t std::shared_ptr irdb_entry_id_name_tv_; std::shared_ptr irdb_entry_id_name_avr_; + std::shared_ptr irdb_manufacturer_tv_; + std::shared_ptr irdb_model_tv_; + std::shared_ptr irdb_manufacturer_avr_; + std::shared_ptr irdb_model_avr_; std::shared_ptr voice_metrics_; diff --git a/src/database/ctrlm_database.cpp b/src/database/ctrlm_database.cpp index 2e9e6e5c..cc4df6c0 100644 --- a/src/database/ctrlm_database.cpp +++ b/src/database/ctrlm_database.cpp @@ -76,6 +76,10 @@ using namespace std; #define CTRLM_DB_AVR_IR_CODE_ID "avr_ir_code_id" #define CTRLM_DB_AVR_IR_VENDOR_ID "avr_ir_vendor_id" #define CTRLM_DB_AVR_IR_VENDOR_NAME "avr_ir_vendor_name" +#define CTRLM_DB_TV_MANUFACTURER "tv_manufacturer" +#define CTRLM_DB_TV_MODEL "tv_model" +#define CTRLM_DB_AVR_MANUFACTURER "avr_manufacturer" +#define CTRLM_DB_AVR_MODEL "avr_model" #define CTRLM_DB_TABLE_VOICE "ctrlm_voice" @@ -476,7 +480,7 @@ gpointer ctrlm_db_thread(gpointer param) { case CTRLM_DB_QUEUE_MSG_TYPE_WRITE_BLOB: { ctrlm_db_queue_msg_write_blob_t *blob = (ctrlm_db_queue_msg_write_blob_t *)msg; XLOGD_DEBUG("WRITE BLOB %s:%s:%u", blob->table, blob->key, blob->length); - ctrlm_print_data_hex(__FUNCTION__, blob->value, blob->length, 16); + // ctrlm_print_data_hex(__FUNCTION__, blob->value, blob->length, 16); ctrlm_db_write_blob_(blob->table, blob->key, blob->value, blob->length); break; } @@ -774,6 +778,70 @@ void ctrlm_db_avr_ir_code_id_read(std::string &id, unsigned char &vendor_id, std } } +void ctrlm_db_tv_manufacturer_write(const std::string manufacturer) { + ctrlm_db_write_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_TV_MANUFACTURER, (const guchar*) manufacturer.c_str(), manufacturer.length()); +} + +void ctrlm_db_tv_manufacturer_read(std::string &manufacturer) { + guchar *data = NULL; + guint32 length = 0; + ctrlm_db_read_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_TV_MANUFACTURER, &data, &length); + if(NULL != data) { + manufacturer.assign((char *)data, length); + ctrlm_db_free(data); + } else { + XLOGD_WARN("Failed to load tv_manufacturer from db"); + } +} + +void ctrlm_db_tv_model_write(const std::string model) { + ctrlm_db_write_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_TV_MODEL, (const guchar*) model.c_str(), model.length()); +} + +void ctrlm_db_tv_model_read(std::string &model) { + guchar *data = NULL; + guint32 length = 0; + ctrlm_db_read_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_TV_MODEL, &data, &length); + if(NULL != data) { + model.assign((char *)data, length); + ctrlm_db_free(data); + } else { + XLOGD_WARN("Failed to load tv_model from db"); + } +} + +void ctrlm_db_avr_manufacturer_write(const std::string manufacturer) { + ctrlm_db_write_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_AVR_MANUFACTURER, (const guchar*) manufacturer.c_str(), manufacturer.length()); +} + +void ctrlm_db_avr_manufacturer_read(std::string &manufacturer) { + guchar *data = NULL; + guint32 length = 0; + ctrlm_db_read_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_AVR_MANUFACTURER, &data, &length); + if(NULL != data) { + manufacturer.assign((char *)data, length); + ctrlm_db_free(data); + } else { + XLOGD_WARN("Failed to load avr_manufacturer from db"); + } +} + +void ctrlm_db_avr_model_write(const std::string model) { + ctrlm_db_write_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_AVR_MODEL, (const guchar*) model.c_str(), model.length()); +} + +void ctrlm_db_avr_model_read(std::string &model) { + guchar *data = NULL; + guint32 length = 0; + ctrlm_db_read_blob(CTRLM_DB_TABLE_CTRLMGR, CTRLM_DB_AVR_MODEL, &data, &length); + if(NULL != data) { + model.assign((char *)data, length); + ctrlm_db_free(data); + } else { + XLOGD_WARN("Failed to load avr_model from db"); + } +} + const char *ctrlm_db_errmsg(int rc) { if(rc == SQLITE_ROW || rc == SQLITE_DONE) { // these are non-error result codes return(""); diff --git a/src/database/ctrlm_database.h b/src/database/ctrlm_database.h index f842c71f..0dfe9106 100644 --- a/src/database/ctrlm_database.h +++ b/src/database/ctrlm_database.h @@ -81,6 +81,14 @@ void ctrlm_db_tv_ir_code_id_write(const std::string id, unsigned char vendor_id, void ctrlm_db_tv_ir_code_id_read(std::string &id, unsigned char &vendor_id, std::string &vendor_name); void ctrlm_db_avr_ir_code_id_write(const std::string id, unsigned char vendor_id, const std::string vendor_name); void ctrlm_db_avr_ir_code_id_read(std::string &id, unsigned char &vendor_id, std::string &vendor_name); +void ctrlm_db_tv_manufacturer_write(const std::string manufacturer); +void ctrlm_db_tv_manufacturer_read(std::string &manufacturer); +void ctrlm_db_tv_model_write(const std::string model); +void ctrlm_db_tv_model_read(std::string &model); +void ctrlm_db_avr_manufacturer_write(const std::string manufacturer); +void ctrlm_db_avr_manufacturer_read(std::string &manufacturer); +void ctrlm_db_avr_model_write(const std::string model); +void ctrlm_db_avr_model_read(std::string &model); void ctrlm_db_rf4ce_networks_list(std::vector *network_ids); void ctrlm_db_rf4ce_controllers_list(ctrlm_network_id_t network_id, std::vector *controller_ids); diff --git a/src/irdb/ctrlm_irdb_interface.cpp b/src/irdb/ctrlm_irdb_interface.cpp index ad847489..4de80492 100644 --- a/src/irdb/ctrlm_irdb_interface.cpp +++ b/src/irdb/ctrlm_irdb_interface.cpp @@ -424,6 +424,11 @@ bool ctrlm_irdb_interface_t::get_irdb_entry_ids(ctrlm_irdb_entry_id_list_t &code if (g_irdb.pluginGetEntryIds) { ret = (*g_irdb.pluginGetEntryIds)(codes, type, manufacturer, model); } + if(ret) { + m_last_entry_id_manufacturer[type] = manufacturer; + m_last_entry_id_model[type] = model; + m_last_entry_ids[type] = codes; + } return ret; } @@ -604,6 +609,25 @@ 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() ); } + m_last_entry_ids.clear(); + m_last_entry_id_manufacturer.clear(); + m_last_entry_id_model.clear(); + for(const auto &type_codes : codes) { + ctrlm_irdb_entry_id_list_t entry_ids; + entry_ids.reserve(type_codes.second.size()); + for(const auto &entry : type_codes.second) { + entry_ids.push_back(entry.id); + } + m_last_entry_ids[type_codes.first] = entry_ids; + + // The different auto lookup methods may return a different manufacturer and model for the same device. + // There is no way of knowing which one is correct. For now, just use the highest ranked which is the first one in the list. + if(!type_codes.second.empty()) { + m_last_entry_id_manufacturer[type_codes.first] = type_codes.second.front().manufacturer; + m_last_entry_id_model[type_codes.first] = type_codes.second.front().model; + } + } + #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; @@ -636,8 +660,28 @@ bool ctrlm_irdb_interface_t::get_ir_codes_by_autolookup(ctrlm_autolookup_ranked_ bool ctrlm_irdb_interface_t::program_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_irdb_dev_type_t type, const std::string &id) { std::unique_lock guard(m_mutex); bool ret = false; + std::string manufacturer; + std::string model; - XLOGD_INFO("Programming IR codes for (%u, %u) with database id <%s>", network_id, controller_id, id.c_str()); + + auto ids_itr = m_last_entry_ids.find(type); + if(ids_itr != m_last_entry_ids.end() && std::find(ids_itr->second.begin(), ids_itr->second.end(), id) != ids_itr->second.end()) { + auto manufacturer_itr = m_last_entry_id_manufacturer.find(type); + auto model_itr = m_last_entry_id_model.find(type); + if(manufacturer_itr != m_last_entry_id_manufacturer.end()) { + manufacturer = manufacturer_itr->second; + } + if(model_itr != m_last_entry_id_model.end()) { + model = model_itr->second; + } + } + + XLOGD_INFO("Programming IR codes for (%u, %u) with database id <%s>, manufacturer <%s>, model <%s>", + network_id, + controller_id, + id.c_str(), + manufacturer.empty() ? "INVALID" : manufacturer.c_str(), + model.empty() ? "INVALID" : model.c_str()); ctrlm_irdb_ir_code_set_t code_set; if (g_irdb.pluginGetCodeSet) { @@ -645,14 +689,14 @@ bool ctrlm_irdb_interface_t::program_ir_codes(ctrlm_network_id_t network_id, ctr XLOGD_ERROR("Failed getting IR code set"); } else { guard.unlock(); - ret = this->_program_ir_codes(network_id, controller_id, &code_set); + ret = this->_program_ir_codes(network_id, controller_id, &code_set, manufacturer, model); } } return(ret); } -bool ctrlm_irdb_interface_t::_program_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_irdb_ir_code_set_t *ir_codes) { +bool ctrlm_irdb_interface_t::_program_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_irdb_ir_code_set_t *ir_codes, const std::string &manufacturer, const std::string &model) { bool ret = false; vector success_vec; @@ -660,6 +704,8 @@ bool ctrlm_irdb_interface_t::_program_ir_codes(ctrlm_network_id_t network_id, ct msg->network_id = network_id; msg->controller_id = controller_id; msg->ir_codes = ir_codes; + msg->manufacturer = manufacturer; + msg->model = model; msg->success = &success_vec; if (false == get_vendor_info(msg->vendor_info)) { diff --git a/src/irdb/ctrlm_irdb_interface.h b/src/irdb/ctrlm_irdb_interface.h index 2f532b15..7cc9728f 100644 --- a/src/irdb/ctrlm_irdb_interface.h +++ b/src/irdb/ctrlm_irdb_interface.h @@ -41,6 +41,8 @@ typedef struct { ctrlm_network_id_t network_id; ctrlm_controller_id_t controller_id; ctrlm_irdb_ir_code_set_t * ir_codes; + std::string manufacturer; + std::string model; std::vector * success; sem_t * semaphore; ctrlm_irdb_vendor_info_t vendor_info; @@ -91,7 +93,7 @@ class ctrlm_irdb_interface_t { bool open_plugin(); bool close_plugin(); - bool _program_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_irdb_ir_code_set_t *ir_codes); + bool _program_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_irdb_ir_code_set_t *ir_codes, const std::string &manufacturer = "", const std::string &model = ""); bool _clear_ir_codes(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id); void *m_irdbPluginHandle; @@ -99,6 +101,9 @@ class ctrlm_irdb_interface_t { ctrlm_irdb_mode_t mode; bool m_platform_tv; std::mutex m_mutex; + std::map m_last_entry_id_manufacturer; + std::map m_last_entry_id_model; + std::map m_last_entry_ids; }; #endif diff --git a/src/network/ctrlm_ir_rf_db.cpp b/src/network/ctrlm_ir_rf_db.cpp index 6c821f5a..d36b8aa9 100644 --- a/src/network/ctrlm_ir_rf_db.cpp +++ b/src/network/ctrlm_ir_rf_db.cpp @@ -47,6 +47,10 @@ ctrlm_ir_rf_db_t::ctrlm_ir_rf_db_t(bool power_toggle_favor_tv, bool power_discre this->avr_ir_code_id_ = "0"; this->avr_ir_vendor_id_ = 0; this->avr_ir_vendor_name_ = "INVALID"; + this->tv_manufacturer_ = "INVALID"; + this->tv_model_ = "INVALID"; + this->avr_manufacturer_ = "INVALID"; + this->avr_model_ = "INVALID"; } ctrlm_ir_rf_db_t::~ctrlm_ir_rf_db_t() { @@ -178,21 +182,25 @@ ctrlm_key_code_t to_ctrlm_keycode(ctrlm_irdb_key_code_t irdb_code) { } } -bool ctrlm_ir_rf_db_t::add_irdb_codes(ctrlm_irdb_ir_code_set_t *ir_codes, unsigned char ir_vendor_id, const std::string &ir_vendor_name) { +bool ctrlm_ir_rf_db_t::add_irdb_codes(ctrlm_irdb_ir_code_set_t *ir_codes, const std::string &manufacturer, const std::string &model, unsigned char ir_vendor_id, const std::string &ir_vendor_name) { bool ret = false; if(ir_codes) { ctrlm_ir_rf_db_dev_type_t type = ctrlm_ir_rf_db_entry_t::type_from_irdb(ir_codes->type); switch(type) { case CTRLM_IR_RF_DB_DEV_TV: { this->tv_ir_code_id_ = ir_codes->id; + this->tv_manufacturer_ = manufacturer.empty() ? "INVALID" : manufacturer; + this->tv_model_ = model.empty() ? "INVALID" : model; this->tv_ir_vendor_id_ = ir_vendor_id; - this->tv_ir_vendor_name_ = ir_vendor_name; + this->tv_ir_vendor_name_ = ir_vendor_name.empty() ? "INVALID" : ir_vendor_name; break; } case CTRLM_IR_RF_DB_DEV_AVR: { this->avr_ir_code_id_ = ir_codes->id; + this->avr_manufacturer_ = manufacturer.empty() ? "INVALID" : manufacturer; + this->avr_model_ = model.empty() ? "INVALID" : model; this->avr_ir_vendor_id_ = ir_vendor_id; - this->avr_ir_vendor_name_ = ir_vendor_name; + this->avr_ir_vendor_name_ = ir_vendor_name.empty() ? "INVALID" : ir_vendor_name; break; } default: { @@ -245,6 +253,8 @@ void ctrlm_ir_rf_db_t::clear_tv_ir_codes() { this->fix_common_slots_and_ir_flags(); this->tv_ir_code_id_ = "0"; + this->tv_manufacturer_ = "INVALID"; + this->tv_model_ = "INVALID"; this->tv_ir_vendor_id_ = 0; this->tv_ir_vendor_name_ = "INVALID"; } @@ -280,6 +290,8 @@ void ctrlm_ir_rf_db_t::clear_avr_ir_codes() { this->fix_common_slots_and_ir_flags(); this->avr_ir_code_id_ = "0"; + this->avr_manufacturer_ = "INVALID"; + this->avr_model_ = "INVALID"; this->avr_ir_vendor_id_ = 0; this->avr_ir_vendor_name_ = "INVALID"; } @@ -293,6 +305,10 @@ void ctrlm_ir_rf_db_t::clear_ir_codes() { this->tv_ir_vendor_id_ = 0; this->tv_ir_vendor_name_ = "INVALID"; this->avr_ir_code_id_ = "0"; + this->tv_manufacturer_ = "INVALID"; + this->tv_model_ = "INVALID"; + this->avr_manufacturer_ = "INVALID"; + this->avr_model_ = "INVALID"; this->avr_ir_vendor_id_ = 0; this->avr_ir_vendor_name_ = "INVALID"; } @@ -308,10 +324,14 @@ ctrlm_ir_rf_db_entry_t *ctrlm_ir_rf_db_t::get_ir_code(ctrlm_key_code_t key) { std::string ctrlm_ir_rf_db_t::to_string(bool debug) const { std::stringstream ss; ss << "IR RF Database: "<< std::endl; - ss << "\tTV IR Code ID <" << tv_ir_code_id_ << ">" << std::endl; ss << "\tTV IR Vendor Info <" << tv_ir_vendor_name_ << ": " << (unsigned int)tv_ir_vendor_id_ << ">" << std::endl; - ss << "\tAVR IR Code ID <" << avr_ir_code_id_ << ">" << std::endl; + ss << "\tTV IR Code ID <" << tv_ir_code_id_ << ">" << std::endl; + ss << "\tTV Manufacturer <" << tv_manufacturer_ << ">" << std::endl; + ss << "\tTV Model <" << tv_model_ << ">" << std::endl; ss << "\tAVR IR Vendor Info <" << avr_ir_vendor_name_ << ": " << (unsigned int)avr_ir_vendor_id_ << ">" << std::endl; + ss << "\tAVR IR Code ID <" << avr_ir_code_id_ << ">" << std::endl; + ss << "\tAVR Manufacturer <" << avr_manufacturer_ << ">" << std::endl; + ss << "\tAVR Model <" << avr_model_ << ">" << std::endl; for(auto itr = this->ir_rf_db.begin(); itr != this->ir_rf_db.end(); itr++) { if(itr->second != NULL) { ss << "\tKeySlot <" << ctrlm_key_code_str(itr->first) << ">, " << itr->second->to_string(debug) << std::endl; @@ -412,6 +432,10 @@ void ctrlm_ir_rf_db_t::load_db() { } ctrlm_db_tv_ir_code_id_read(tv_ir_code_id_, tv_ir_vendor_id_, tv_ir_vendor_name_); ctrlm_db_avr_ir_code_id_read(avr_ir_code_id_, avr_ir_vendor_id_, avr_ir_vendor_name_); + ctrlm_db_tv_manufacturer_read(tv_manufacturer_); + ctrlm_db_tv_model_read(tv_model_); + ctrlm_db_avr_manufacturer_read(avr_manufacturer_); + ctrlm_db_avr_model_read(avr_model_); } bool ctrlm_ir_rf_db_t::store_db() { @@ -420,6 +444,10 @@ bool ctrlm_ir_rf_db_t::store_db() { } ctrlm_db_tv_ir_code_id_write(tv_ir_code_id_, tv_ir_vendor_id_, tv_ir_vendor_name_); ctrlm_db_avr_ir_code_id_write(avr_ir_code_id_, avr_ir_vendor_id_, avr_ir_vendor_name_); + ctrlm_db_tv_manufacturer_write(tv_manufacturer_); + ctrlm_db_tv_model_write(tv_model_); + ctrlm_db_avr_manufacturer_write(avr_manufacturer_); + ctrlm_db_avr_model_write(avr_model_); return(true); // TODO, maybe change to void } diff --git a/src/network/ctrlm_ir_rf_db.h b/src/network/ctrlm_ir_rf_db.h index d383e3d5..838b89d9 100644 --- a/src/network/ctrlm_ir_rf_db.h +++ b/src/network/ctrlm_ir_rf_db.h @@ -58,9 +58,9 @@ class ctrlm_ir_rf_db_t { /** * Function to add a CTRLM IRDB ir_codes to the IR RF Database * @param ir_codes A keymap supplied from the CTRLM IRDB component - * @reutrn True if the entries were added to the IRRF Database, False otherwise. + * @return True if the entries were added to the IRRF Database, False otherwise. */ - bool add_irdb_codes(ctrlm_irdb_ir_code_set_t *ir_codes, unsigned char ir_vendor_id = 0, const std::string &ir_vendor_name = ""); + bool add_irdb_codes(ctrlm_irdb_ir_code_set_t *ir_codes, const std::string &manufacturer = "INVALID", const std::string &model = "INVALID", unsigned char ir_vendor_id = 0, const std::string &ir_vendor_name = ""); /** * Function to clear all TV IR codes stored in the IR RF Database @@ -187,6 +187,10 @@ class ctrlm_ir_rf_db_t { std::string avr_ir_code_id_; unsigned char avr_ir_vendor_id_; std::string avr_ir_vendor_name_; + std::string tv_manufacturer_; + std::string tv_model_; + std::string avr_manufacturer_; + std::string avr_model_; }; diff --git a/src/rf4ce/ctrlm_rf4ce_network.cpp b/src/rf4ce/ctrlm_rf4ce_network.cpp index db7a2302..f22e36b3 100644 --- a/src/rf4ce/ctrlm_rf4ce_network.cpp +++ b/src/rf4ce/ctrlm_rf4ce_network.cpp @@ -4250,7 +4250,7 @@ void ctrlm_obj_network_rf4ce_t::req_process_program_ir_codes(void *data, int siz bool success = false; if(!is_managed_by_network(dqm->controller_id)) { - XLOGD_ERROR("controller %d is not managed by the %s network", dqm->controller_id, name_get()); + XLOGD_WARN("controller %d is not managed by the %s network", dqm->controller_id, name_get()); } else if(controller_exists(dqm->controller_id)) { if(dqm->ir_codes) { XLOGD_INFO("Setting IR Codes on Controller %u", dqm->controller_id);