src_client/DeviceManagerClient.cc

   1 /*
   2  * DeviceManagerClient.cc
   3  *
   4  *  Created on: Mar 4, 2011
   5  *      Author: lamikr
   6  */
   7 #include <sstream>
   8 #include <string>
   9
  10 #include <plp/log.h>
  11 #include <plp/retval.h>
  12
  13 #include <plp/Data.hh>
  14 #include <plp/DeviceData.hh>
  15
  16 #include "DeviceManagerClient.hh"
  17 #include "../src/plp/devicebus/DeviceBusMessageId.hh"
  18
  19 using namespace std;
  20 using namespace plp;
  21 using namespace plpbus;
  22 using namespace plpdevicebus;
  23
  24 DeviceManagerClient::DeviceManagerClient() {
  25         _device_list    = NULL;
  26 }
  27
  28 static void clean_device_list(list<Device *> *dev_lst) {
  29         Device  *dev;
  30
  31         if (dev_lst != NULL) {
  32                 while (dev_lst->empty() == false) {
  33                         dev     = dev_lst->back();
  34                         dev_lst->pop_back();
  35                         delete(dev);
  36                 }
  37                 delete(dev_lst);
  38                 dev_lst = NULL;
  39         }
  40 }
  41
  42 DeviceManagerClient::~DeviceManagerClient() {
  43         clean_device_list(_device_list);
  44 }
  45
  46 const std::list<plp::Device *> *DeviceManagerClient::get_device_list(BusClient *client_param,
  47                                                                 int *err_flg) {
  48         BusMessage      *msg_req;
  49         BusMessage      *msg_rsp;
  50
  51         msg_rsp = NULL;
  52         msg_req = new BusMessage(MSG_TYPE_ID__GET_DEVICE_LIST);
  53         client_param->send_message_and_wait_response(msg_req, &msg_rsp);
  54         clean_device_list(_device_list);
  55         _device_list    = parse_device_list_msg(msg_rsp, err_flg);
  56         delete(msg_req);
  57         delete(msg_rsp);
  58
  59         return _device_list;
  60 }
  61
  62 void DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
  63                                         DataRange *result,
  64                                         string key,
  65                                         int *err_flg,
  66                                         string description) {
  67         string          data_str;
  68         Data            *data;
  69
  70         *err_flg        = PLP_ERR;
  71         data            = NULL;
  72         if ((msg_param != NULL) &&
  73             (result != NULL)) {
  74                 data_str        = msg_param->get_string_parameter(RSP__GET_LATEST_DATA__VALUE, err_flg);
  75                 if (data_str.empty() == false) {
  76                         data    = Data::parse_string(data_str);
  77                 }
  78                 if (data != NULL) {
  79                         result->add(data);
  80                         log_debug("%s\n", description.c_str());
  81                         data->printout();
  82                         delete(data);
  83                 }
  84         }
  85 }
  86
  87 DataRange *DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
  88                                                 int *err_flg) {
  89         DataRange       *ret_val;
  90
  91         *err_flg        = PLP_ERR;
  92         ret_val         = NULL;
  93         if (msg_param != NULL) {
  94                 ret_val         = new DataRange();
  95                 parse_device_data_msg(msg_param, ret_val, RSP__GET_LATEST_DATA__VALUE, err_flg, "latest data");
  96                 parse_device_data_msg(msg_param, ret_val, RSP__GET_LATEST_DATA__MIN_VALUE, err_flg, "min data value");
  97                 parse_device_data_msg(msg_param, ret_val, RSP__GET_LATEST_DATA__MAX_VALUE, err_flg, "max data value");
  98
  99                 *err_flg        = PLP_OK;
 100         }
 101         return ret_val;
 102 }
 103
 104 Data *DeviceManagerClient::get_latest_data(BusClient *client_param,
 105                                         string device_id_param,
 106                                         int *err_flg) {
 107         BusMessage      *msg_req;
 108         BusMessage      *msg_rsp;
 109         Data            *ret_val;
 110         DataRange       *dr;
 111
 112         msg_rsp = NULL;
 113         ret_val = NULL;
 114         msg_req = new BusMessage(MSG_TYPE_ID__GET_LATEST_DATA);
 115         msg_req->add_string_parameter(REQ__GET_LATEST_DATA__ID, device_id_param.c_str());
 116         client_param->send_message_and_wait_response(msg_req, &msg_rsp);
 117         dr      = parse_device_data_msg(msg_rsp, err_flg);
 118         ret_val = dr->get_first();
 119         delete(dr);
 120         delete(msg_req);
 121         delete(msg_rsp);
 122
 123         return ret_val;
 124 }
 125
 126 list<Device *> *DeviceManagerClient::parse_device_list_msg(BusMessage *msg_param,
 127                                                         int *err_flg) {
 128         int                             ii;
 129         long                            count;
 130         ostringstream                   key;
 131         string                          id;
 132         string                          name;
 133         string                          type;
 134         string                          datastr;
 135         EnumDeviceLifeCycleStatus       state;
 136         int                             state_i;
 137         Device                          *dev;
 138         Data                            *data;
 139         list<Device *>                  *ret_val;
 140
 141         ret_val = new list<Device *>;
 142         count   = msg_param->get_long_parameter(RSP__DEVICE_LIST__DEVICE_COUNT, err_flg);
 143         log_debug("device count: %ld\n", count);
 144         if (*err_flg == PLP_OK) {
 145                 for (ii = 0; ii < count; ii++) {
 146                         data    = NULL;
 147
 148                         key.str("");
 149                         key << RSP__DEVICE_LIST__ID << ii;
 150                         id      = msg_param->get_string_parameter(key.str(), err_flg);
 151                         if (*err_flg != PLP_OK) {
 152                                 log_error("Failed to parse device id.\n");
 153                                 break;
 154                         }
 155
 156                         key.str("");
 157                         key << RSP__DEVICE_LIST__NAME << ii;
 158                         name    = msg_param->get_string_parameter(key.str(), err_flg);
 159                         if (*err_flg != PLP_OK) {
 160                                 log_error("Failed to parse name for the device: %s\n", id.c_str());
 161                                 break;
 162                         }
 163
 164                         key.str("");
 165                         key << RSP__DEVICE_LIST__TYPE << ii;
 166                         type    = msg_param->get_string_parameter(key.str(), err_flg);
 167                         if (*err_flg != PLP_OK) {
 168                                 log_error("Failed to parse type for the device: %s\n", id.c_str());
 169                                 break;
 170                         }
 171
 172                         key.str("");
 173                         key << RSP__DEVICE_LIST__LF_STATE << ii;
 174                         state_i = msg_param->get_int_parameter(key.str(), err_flg);
 175                         if (*err_flg != PLP_OK) {
 176                                 log_error("Failed to parse life cycle state for the device: %s\n", id.c_str());
 177                                 break;
 178                         }
 179                         state   = (EnumDeviceLifeCycleStatus)state_i;
 180
 181                         key.str("");
 182                         key << RSP__DEVICE_LIST__DATA << ii;
 183                         datastr = msg_param->get_string_parameter(key.str(), err_flg);
 184                         if (*err_flg == PLP_OK) {
 185                                 data    = Data::parse_string(datastr);
 186                                 if (data == NULL) {
 187                                         log_error("No data available for the device: %s\n", id.c_str());
 188                                 }
 189                         }
 190                         else {
 191                                 log_error("No data available for the device: %s\n", id.c_str());
 192                         }
 193                         dev     = new DeviceData(id, type, name, state, data);
 194                         ret_val->push_back(dev);
 195                 }
 196         }
 197         return ret_val;
 198 }