RDKEMW-11471: Remove netType param

src/ble/ctrlm_ble_controller.cpp

@@ -654,4 +654,21 @@ void ctrlm_obj_controller_ble_t::print_status() {
    XLOGD_WARN("------------------------------------------------------------");
 }
 
+void ctrlm_obj_controller_ble_t::update_controller_id_and_db_entry(std::string db_name, ctrlm_network_id_t network_id, ctrlm_controller_id_t new_id) {
+    ctrlm_obj_controller_t::update_controller_id_and_db_entry(db_name, network_id, new_id);
+
+    std::stringstream new_controller_db_table;
+    new_controller_db_table << db_name << "_" << COUT_HEX_MODIFIER << (int)network_id << "_controller_" << COUT_HEX_MODIFIER << (int)new_id;
+    std::string new_table = new_controller_db_table.str();
+
+    product_name_->set_table(new_table);
+    serial_number_->set_table(new_table);
+    manufacturer_->set_table(new_table);
+    model_->set_table(new_table);
+    fw_revision_->set_table(new_table);
+    sw_revision_->set_table(new_table);
+    hw_revision_->set_table(new_table);
+    battery_percent_->set_table(new_table);
+}
+
 // End Function Implementations

src/ble/ctrlm_ble_controller.h

@@ -147,6 +147,8 @@ class ctrlm_obj_controller_ble_t : public ctrlm_obj_controller_t {
    ctrlm_timestamp_t                getVoiceStartTimeKey() const;
    ctrlm_timestamp_t                getVoiceStartTimeLocal() const;
 
+   void                             update_controller_id_and_db_entry(std::string name, ctrlm_network_id_t network_id, ctrlm_controller_id_t new_id);
+
 private:
    ctrlm_obj_network_ble_t                *obj_network_ble_ = NULL;
 

src/ble/ctrlm_ble_network.cpp

@@ -779,13 +779,15 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size)
    g_assert(dqm);
    g_assert(size == sizeof(ctrlm_main_queue_msg_program_ir_codes_t));
 
-   if(dqm->success) {*(dqm->success) = false;}
+   bool success = false;
 
    if (!ready_) {
       XLOGD_FATAL("Network is not ready!");
    } else {
       ctrlm_controller_id_t controller_id = dqm->controller_id;
-      if (!controller_exists(controller_id)) {
+      if (!is_managed_by_network(controller_id)) {
+         XLOGD_ERROR("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)) {
          XLOGD_ERROR("Unsupported IRDB - not continuing with ir code download!");
@@ -815,19 +817,18 @@ void ctrlm_obj_network_ble_t::req_process_program_ir_codes(void *data, int size)
 
                   XLOGD_ERROR("failed to program IR signal waveforms on remote");
                } else {
-
-                     if (dqm->success) { *(dqm->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());
+                  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());
                }
             }
             // Store the IR codes in the database
             ir_rf_database_.store_db();
          }
       }
    }
+   if(dqm->success) {dqm->success->push_back(success);}
    if(dqm->semaphore) {
       sem_post(dqm->semaphore);
    }
@@ -842,23 +843,23 @@ void ctrlm_obj_network_ble_t::req_process_ir_clear_codes(void *data, int size) {
    g_assert(dqm);
    g_assert(size == sizeof(ctrlm_main_queue_msg_ir_clear_t));
 
-   if(dqm->success) {*(dqm->success) = false;}
+   bool success = false;
 
    if (!ready_) {
       XLOGD_FATAL("Network is not ready!");
    } else {
       ctrlm_controller_id_t controller_id = dqm->controller_id;
-      if (!controller_exists(controller_id)) {
+      if (!is_managed_by_network(controller_id)) {
+         XLOGD_ERROR("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 (ble_rcu_interface_) {
             if (!ble_rcu_interface_->eraseIrSignals(controllers_[controller_id]->ieee_address_get().get_value())) {
                XLOGD_ERROR("failed to erase IR signal waveforms on remote");
             } else {
-
-               if (dqm->success) { *(dqm->success) = true; }
-
+               success = true;
                ir_rf_database_.clear_ir_codes();
                XLOGD_INFO("\n%s", ir_rf_database_.to_string(true).c_str());
                controllers_[controller_id]->irdb_entry_id_name_set(CTRLM_IRDB_DEV_TYPE_TV, "0");
@@ -868,6 +869,7 @@ void ctrlm_obj_network_ble_t::req_process_ir_clear_codes(void *data, int size) {
          ir_rf_database_.store_db();
       }
    }
+   if(dqm->success) {dqm->success->push_back(success);}
    if(dqm->semaphore) {
       sem_post(dqm->semaphore);
    }
@@ -973,7 +975,7 @@ void ctrlm_obj_network_ble_t::req_process_find_my_remote(void *data, int size) {
       ctrlm_controller_id_t controller_id = get_last_used_controller();
 
       if (CTRLM_HAL_CONTROLLER_ID_INVALID == controller_id) {
-         XLOGD_ERROR("no connected controllers to find!!");
+         XLOGD_ERROR("no connected %s controllers to find!!", name_get());
          dqm->params->set_result(CTRLM_IARM_CALL_RESULT_ERROR, network_id_get());
       } else {
          if (ble_rcu_interface_) {
@@ -2440,7 +2442,7 @@ void ctrlm_obj_network_ble_t::controller_remove(ctrlm_controller_id_t controller
 
 ctrlm_controller_id_t ctrlm_obj_network_ble_t::controller_id_assign() {
    // Get the next available controller id
-   for(ctrlm_controller_id_t index = 1; index < CTRLM_MAIN_CONTROLLER_ID_ALL; index++) {
+   for(ctrlm_controller_id_t index = BLE_RCU_ID_RANGE_MIN; index < BLE_RCU_ID_RANGE_MAX; index++) {
       if(!controller_exists(index)) {
          XLOGD_INFO("controller id %u", index);
          return(index);
@@ -2463,10 +2465,26 @@ void ctrlm_obj_network_ble_t::controllers_load() {
          XLOGD_WARN("deleting legacy IR controller object");
          add_controller->db_destroy();
          delete add_controller;
-      } else {
-         XLOGD_INFO("adding BLE controller with ID = 0x%X", id);
-         controllers_[id] = add_controller;
+         continue;
       }
+      if (!is_managed_by_network(id)) {
+         ctrlm_controller_id_t new_id = controller_id_assign();
+
+         add_controller->db_destroy(); // safely can destroy the old entry since it was loaded earlier
+
+         if (new_id == 0) {
+             XLOGD_ERROR("Unable to assign a new ID - deleting controller <%d>", id);
+             delete add_controller;
+             continue;
+         }
+
+         add_controller->update_controller_id_and_db_entry(db_name_get(), network_id_get(), new_id);
+         add_controller->db_create(); // create the new entry with its new ID
+         XLOGD_WARN("Legacy BLE RCU controller id <%d> found - updating controller id to <%d>", id, new_id);
+         id = new_id;
+      }
+      XLOGD_INFO("adding BLE controller with ID = 0x%X", id);
+      controllers_[id] = add_controller;
    }
 }
 
@@ -2655,3 +2673,7 @@ void ctrlm_obj_network_ble_t::start_controller_audio_streaming(ctrlm_voice_start
     params->m_fd = fd;
     params->m_started = true;
 }
+
+bool ctrlm_obj_network_ble_t::is_managed_by_network(ctrlm_controller_id_t id) {
+    return (id >= BLE_RCU_ID_RANGE_MIN && id < BLE_RCU_ID_RANGE_MAX);
+}

src/ble/ctrlm_ble_network.h

@@ -41,6 +41,8 @@
 
 // End Includes
 
+#define BLE_RCU_ID_RANGE_MIN (NETWORK_ID_BASE_BLE)
+#define BLE_RCU_ID_RANGE_MAX ((BLE_RCU_ID_RANGE_MIN)+BLE_MAX_MANAGED_RCUS+1) // +1 as a buffer for pairing
 
 typedef struct {
    ctrlm_main_queue_msg_header_t               header;
@@ -194,6 +196,9 @@ class ctrlm_obj_network_ble_t : public ctrlm_obj_network_t {
 
    virtual void                  start_controller_audio_streaming(ctrlm_voice_start_audio_params_t *params);
 
+protected:
+   virtual bool                  is_managed_by_network(ctrlm_controller_id_t id);
+
 private:
    ctrlm_obj_network_ble_t();
 

src/ble/hal/blercu/blercucontroller.cpp

@@ -65,7 +65,7 @@ BleRcuControllerImpl::BleRcuControllerImpl(const shared_ptr<const ConfigSettings
     , m_adapter(adapter)
     , m_pairingStateMachine(config, m_adapter)
     , m_lastError(BleRcuError::NoError)
-    , m_maxManagedDevices(1)
+    , m_maxManagedDevices(BLE_MAX_MANAGED_RCUS)
     , m_state(Initialising)
     , m_ignorePairingFailure(false)
 {

src/ble/hal/blercu/blercucontroller_p.h

@@ -35,13 +35,13 @@
 
 #include <string>
 
+#define BLE_MAX_MANAGED_RCUS (1)
+
 class ConfigSettings;
 
 class BleRcuAdapter;
 class BleRcuDevice;
 
-
-
 class BleRcuControllerImpl final : public BleRcuController
 {
 public:

src/ctrlm_controller.cpp

@@ -410,3 +410,20 @@ uint8_t ctrlm_obj_controller_t::get_upgrade_increment() const {
 bool ctrlm_obj_controller_t::is_upgrade_progress_at_increment() const {
     return ((upgrade_progress_ % upgrade_increment_ == 0) || (upgrade_progress_ == 100));
 }
+
+void ctrlm_obj_controller_t::update_controller_id_and_db_entry(std::string db_name, ctrlm_network_id_t network_id, ctrlm_controller_id_t new_id) {
+    controller_id_ = new_id;
+    std::stringstream new_controller_db_table;
+    new_controller_db_table << db_name << "_" << COUT_HEX_MODIFIER << (int)network_id << "_controller_" << COUT_HEX_MODIFIER << (int)new_id;
+    std::string new_table = new_controller_db_table.str();
+
+    ieee_address_->set_table(new_table);
+    time_binding_->set_table(new_table);
+    last_activity_time_->set_table(new_table);
+    last_key_time_->set_table(new_table);
+    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);
+    voice_metrics_->set_table(new_table);
+    ota_failure_cnt_from_last_success_->set_table(new_table);
+}

src/ctrlm_controller.h

@@ -67,6 +67,7 @@ class ctrlm_obj_controller_t
    std::string             stb_name_get() const;
    void                    set_device_minor_id(int device_minor_id);
    int                     get_device_minor_id() const;
+   void                    update_controller_id_and_db_entry(std::string db_name, ctrlm_network_id_t network_id, ctrlm_controller_id_t id);
 
    virtual ctrlm_controller_capabilities_t get_capabilities() const;
 

src/ctrlm_main.cpp

@@ -113,11 +113,6 @@ using namespace std;
 
 #define CTRLM_MAIN_QUEUE_REPEAT_DELAY   (5000)
 
-#define NETWORK_ID_BASE_RF4CE   1
-#define NETWORK_ID_BASE_IP      11
-#define NETWORK_ID_BASE_BLE     21
-#define NETWORK_ID_BASE_CUSTOM  41
-
 #define CTRLM_MAIN_FIRST_BOOT_TIME_MAX (180) // maximum amount of uptime allowed (in seconds) for declaring "first boot"
 
 typedef void (*ctrlm_queue_push_t)(gpointer);

src/ctrlm_network.cpp

@@ -1079,3 +1079,8 @@ void ctrlm_obj_network_t::start_controller_audio_streaming(ctrlm_voice_start_aud
    XLOGD_WARN("not implemented for %s network", name_get());
    return;
 }
+
+bool ctrlm_obj_network_t::is_managed_by_network(ctrlm_controller_id_t) {
+   XLOGD_WARN("not implemented for %s network", name_get());
+   return false;
+}

src/ctrlm_network.h

@@ -36,6 +36,11 @@
 
 #define THREAD_ID_VALIDATE() thread_id_validate(__FUNCTION__)
 
+#define NETWORK_ID_BASE_RF4CE   1
+#define NETWORK_ID_BASE_IP      11
+#define NETWORK_ID_BASE_BLE     21
+#define NETWORK_ID_BASE_CUSTOM  41
+
 typedef struct : public ctrlm_network_all_ipc_result_wrapper_t {
    unsigned char            api_revision;
    unsigned int             timeout;
@@ -313,6 +318,7 @@ class ctrlm_obj_network_t
    const char *         get_thread_name(const GThread *thread_id) const;
    void                 thread_id_validate(const char *pCallingFunction) const;
    virtual gboolean     key_event_hook(ctrlm_network_id_t network_id, ctrlm_controller_id_t controller_id, ctrlm_key_status_t key_status, ctrlm_key_code_t key_code);
+   virtual bool         is_managed_by_network(ctrlm_controller_id_t id);
 
 private:
    gboolean                      mask_key_codes_ = true;

src/ipc/ctrlm_rcp_ipc_event.cpp

@@ -135,6 +135,23 @@ void ctrlm_rcp_ipc_net_status_t::populate_status(const ctrlm_obj_network_t &netw
     }
 }
 
+ctrlm_ir_state_t ctrlm_rcp_ipc_net_status_t::get_ir_prog_state(void)
+{
+    return irdb_state_;
+}
+
+ctrlm_rf_pair_state_t ctrlm_rcp_ipc_net_status_t::get_rf_pair_state(void)
+{
+    return pair_state_;
+}
+
+void ctrlm_rcp_ipc_net_status_t::get_controller_status_list(std::vector<ctrlm_rcp_ipc_controller_status_t> &list)
+{
+    for (const auto &status : controller_status_list_) {
+        list.push_back(status);
+    }
+}
+
 char *ctrlm_rcp_ipc_net_status_t::to_string() const
 {
     return json_dumps(to_json(), JSON_ENCODE_ANY);

src/ipc/ctrlm_rcp_ipc_event.h

@@ -111,13 +111,18 @@ class ctrlm_rcp_ipc_net_status_t : public ctrlm_virtual_json_t
 
     virtual json_t *to_json() const;
 
-    char              *to_string() const;
-    uint8_t            get_api_revision() const                             { return api_revision_; }
-    bool               get_result() const                                   { return (result_ == CTRLM_IARM_CALL_RESULT_SUCCESS) ? true : false; }
-    void               set_result(ctrlm_iarm_call_result_t result)          { result_ = result; }
-    ctrlm_network_id_t get_net_id() const                                   { return net_id_; }
-    void               set_net_id(ctrlm_network_id_t net_id)                { net_id_ = net_id; }
-    void               populate_status(const ctrlm_obj_network_t &network);
+    char                *to_string() const;
+    uint8_t              get_api_revision() const                    { return api_revision_; }
+    bool                 get_result() const                          { return (result_ == CTRLM_IARM_CALL_RESULT_SUCCESS) ? true : false; }
+    void                 set_result(ctrlm_iarm_call_result_t result) { result_ = result; }
+    ctrlm_network_id_t   get_net_id() const                          { return net_id_; }
+    void                 set_net_id(ctrlm_network_id_t net_id)       { net_id_ = net_id; }
+    ctrlm_network_type_t get_type() const                            { return net_type_; }
+
+    void                  populate_status(const ctrlm_obj_network_t &network);
+    ctrlm_ir_state_t      get_ir_prog_state(void);
+    ctrlm_rf_pair_state_t get_rf_pair_state(void);
+    void                  get_controller_status_list(std::vector<ctrlm_rcp_ipc_controller_status_t> &list);
 
 private:
     uint8_t                  api_revision_   = 0;
@@ -197,11 +202,11 @@ class ctrlm_network_all_ipc_result_wrapper_t {
             return (result_map_[network_id_] == CTRLM_IARM_CALL_RESULT_SUCCESS);
         } else {
             for (const auto &it : result_map_) {
-                if (it.second != CTRLM_IARM_CALL_RESULT_SUCCESS) {
-                    return false;
+                if (it.second == CTRLM_IARM_CALL_RESULT_SUCCESS) {
+                    return true;
                 }
             }
-            return true;
+            return false;
         }
     }
 };