Develop applications using the QSH client APIs

/* Create a new ISession for UID discovery */ 
  sessionFactory* factory = new sessionFactory(); 
  if(nullptr == factory){ 
      printf("failed to create factory instance"); 
      return false; 
  } 
  ISession* suidSession = factory->getSession(); 
  if(nullptr == suidSession){ 
      printf("failed to create uid session"); 
      return false; 
}

/* Open the suidSession */ 
  int ret = suidSession->open(); 
  if(-1 == ret){ 
      printf("failed to open ISession for uid query"); 
      return false; 
}

/* Set callbacks for the session for 'uid' */ 
  ret = suidSession->setCallBacks(uid, suidResp, nullptr, suidEvent); 
  if(-1 == ret) 
      printf("all callbacks are null, no need to register it");

/* 
   * Create SUID request message 
   * (Please refer sns_client.proto and sns_suid.proto for more details) 
   * */ 
   string pb_req_encoded = ""; 
   sns_suid_req pb_suid_req; 
   pb_suid_req.set_data_type(sensorName); 
   pb_suid_req.set_register_updates(true); 
   sns_client_request_msg pb_req_msg; 
   pb_req_msg.set_msg_id(SNS_SUID_MSGID_SNS_SUID_REQ); 
   string pb_req_msg_encoded; 
   pb_req_msg.SerializeToString(&pb_req_msg_encoded); 
   /* send proto encoded message to sensing-hub using the opened session */ 
   unique_lock<mutex> respLock(respMutex); 
   ret = suidSession->sendRequest(uid, pb_req_msg_encoded); 
   if(0 != ret){ 
      printf("Error in sending uid discovery request"); 
      return false; 
}

/* Close and delete the session once SUIDs are received */ 
   suidSession->close(); 
   delete suidSession; 
   delete factory;

/* Create a new ISession for attribute query */ 
  sessionFactory* factory = new sessionFactory(); 
  if(nullptr == factory){ 
      printf("failed to create factory instance"); 
      return false; 
  }

   ISession* attributeSession = factory->getSession(); 
     if(nullptr == attributeSession){ 
         printf("failed to create attribute session"); 
         return false; 
   }

/* open the attributeSession session */ 
  int ret = attributeSession->open(); 
  if(-1 == ret){ 
      printf("failed to open ISession for attribute query"); 
      return false;

for (const suid& uid : suidList) { 
   /* set callbacks for the session for 'uid' */ 
   int ret = attributeSession->setCallBacks(uid, attributeResp, nullptr, attributeEvent); 
   if(-1 == ret) 
      printf("all callbacks are null, no need to register it");

/* create pb-encoded config request message to be sent for attribute query */ 
   sns_client_request_msg pb_req_msg; 
   pb_req_msg.set_msg_id(SNS_STD_MSGID_SNS_STD_ATTR_REQ); 
   pb_req_msg.mutable_request()->clear_payload(); 
   pb_req_msg.mutable_suid()->set_suid_high(uid.high);  
/* send proto encoded message to sensing-hub using the opened session */ 
   unique_lock<mutex> respLock(respMutex); 
   ret = attributeSession->sendRequest(uid, pb_req_msg_encoded);

/* close and delete the session once all attributes are received */ 
   attributeSession->close(); 
   delete attributeSession; 
   delete factory;

``sessionFactory()class.
/* create a new ISession for streaming activity */ 
   sessionFactory* factory = new sessionFactory(); 
   if(nullptr == factory){ 
      printf("failed to create factory instance"); 
      return false; 
   } 
   ISession* streamingSession = factory->getSession(); 
   if(nullptr == streamingSession){ 
      printf("failed to create streaming session"); 
      return false; 
}

/* open the streamingSession session */ 
   int ret = streamingSession->open(); 
   if(-1 == ret){ 
      printf("failed to open ISession for attribute query"); 
      return false;

for (const suid& uid : suidList){ 
   /* set callbacks for the session for 'uid' */ 
   int ret = streamingSession->setCallBacks(uid, dataResp, dataError, dataEvent); 
   if(-1 == ret) 
      printf("all callbacks are null, no need to register it");

/* create pb-encoded config request message to be sent for streaming request */ 
   string pb_req_encoded = ""; 
   sns_std_sensor_config pb_stream_cfg; 
   pb_stream_cfg.set_sample_rate(sampleRate); 
   pb_stream_cfg.SerializeToString(&pb_req_encoded); 
   sns_client_request_msg pb_req_msg; 
   pb_req_msg.mutable_request()->mutable_batching()->set_batch_period(batchPeriod); 
   pb_req_msg.set_msg_id(SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG); 
/* send proto encoded message to sensing-hub using the opened session */ 
   unique_lock<mutex> respLock(respMutex); 
   ret = streamingSession->sendRequest(uid, pb_req_msg_encoded);

   void handle_event_cb(const uint8_t *data, size_t size, uint64_t time_stamp){ 
   if(true == deletion_started){ 
      printf("\nEvent coming when deletion of qmi connection started"); 
      return; 
   } 
   sns_client_event_msg pb_event_msg; 
   /* Parse the pb encoded event */ 
   pb_event_msg.ParseFromArray(data, size); 
   /* Iterate over all events in the message */ 
   for (int i = 0; i < pb_event_msg.events_size(); i++) { 
      auto& pb_event = pb_event_msg.events(i);
   }

   pb_req_msg.set_msg_id(SNS_CLIENT_MSGID_SNS_CLIENT_DISABLE_REQ); 
   pb_req_msg.mutable_suid()->set_suid_high(uid.high); 
   pb_req_msg.mutable_suid()->set_suid_low(uid.low); 
/* send disable request to sensing-hub */ 
   int ret = streamingSession->sendRequest(uid, pb_req_msg_encoded);

/* close and delete the streamingSession */ 
   streamingSession->close(); 
   delete streamingSession; 
   delete factory;