resource/examples/ocicuc/light_resource.cpp

   1 #include "light_resource.hpp"
   2
   3 namespace Intel { namespace OCDemo {
   4
   5 std::atomic<bool> LightResource::shutdown_flag(false);
   6 std::thread LightResource::observe_thread;
   7
   8 void LightResource::setRepresentation(const OCRepresentation& rep)
   9 {
  10  cout << "\t\t\t" << "Received representation: " << endl;
  11
  12  rep.getValue("state", m_state);
  13  rep.getValue("power", m_power);
  14
  15  cout << "\t\t\t\t" << "power: " << m_power << endl;
  16  cout << "\t\t\t\t" << "state: " << m_state << endl;
  17 }
  18
  19 OCRepresentation LightResource::getRepresentation(void)
  20 {
  21  m_rep.setValue("state", m_state);
  22  m_rep.setValue("power", m_power);
  23  return m_rep;
  24 }
  25
  26 void LightResource::addType(const std::string& type) const
  27 {
  28  OCStackResult result = OC::OCPlatform::bindTypeToResource(m_resourceHandle, type);
  29
  30  if(OC_STACK_OK != result)
  31   cout << "Binding TypeName to Resource was unsuccessful, result was " << result << '\n';
  32 }
  33
  34 void LightResource::addInterface(const std::string& interface) const
  35 {
  36  OCStackResult result = OC::OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
  37
  38  if(OC_STACK_OK != result)
  39   cout << "Binding TypeName to Resource was unsuccessful, result was " << result << '\n';
  40 }
  41
  42 void LightResource::createResource(const unsigned int resource_number)
  43 {
  44  string resourceURI      { make_URI(resource_number) };
  45  string resourceTypeName { "core.light" };
  46
  47  cout << "registering resource: " << resourceURI << '\n';
  48  cout << "registering type name \"" << resourceTypeName << "\".\n";
  49  // This will internally create and register the resource, binding the current instance's method as a callback:
  50  OCStackResult result = OC::OCPlatform::registerResource(
  51                                             m_resourceHandle, resourceURI, resourceTypeName,
  52                                             DEFAULT_INTERFACE,
  53                                             std::bind(&LightResource::entityHandler, this, std::placeholders::_1),
  54                                             OC_DISCOVERABLE | OC_OBSERVABLE);
  55   if (OC_STACK_OK != result)
  56    std::cout << "Resource creation failed.\n";
  57 }
  58
  59 void LightResource::observe_function()
  60 {
  61  cerr << "Observation thread is spinning up.\n";
  62
  63  while(!shutdown_flag)
  64   {
  65     std::this_thread::sleep_for(std::chrono::seconds(2));
  66
  67     if(!m_observation)
  68      continue;
  69
  70     m_power += 10;
  71
  72     const auto result = OC::OCPlatform::notifyAllObservers(getHandle());
  73
  74     // Stop notifications when there are no more observers:
  75     if(OC_STACK_NO_OBSERVERS == result)
  76      {
  77         m_observation = 0;
  78      }
  79   }
  80
  81  cerr << "Observation thread is shutting down.\n";
  82 }
  83
  84 void LightResource::unregisterResource()
  85 {
  86     std::cout << "Unregistering light resource"<<std::endl;
  87
  88     OCStackResult result = OC::OCPlatform::unregisterResource(m_resourceHandle);
  89
  90     if(result == OC_STACK_OK)
  91     {
  92         std::cout << "Resource unregistered."<<std::endl;
  93     }
  94     else
  95     {
  96         cerr << "Unregister resource failed: "<<std::endl;
  97     }
  98 }
  99
 100 // This is just a sample implementation of entity handler.
 101 // Entity handler can be implemented in several ways by the manufacturer
 102 OCEntityHandlerResult LightResource::entityHandler(std::shared_ptr<OCResourceRequest> request)
 103 {
 104     if(!request)
 105      {
 106         cerr << "entityHandler(): Received invalid request object.\n";
 107         return OC_EH_ERROR;
 108      }
 109
 110     switch(request->getRequestHandlerFlag())
 111     {
 112         default:
 113                 cerr << "entityHandler(): invalid request flag\n";
 114                 break;
 115
 116         case RequestHandlerFlag::InitFlag:
 117                 cerr << "entityHandler(): Initialization requested.\n";
 118                 break;
 119
 120         case RequestHandlerFlag::RequestFlag:
 121                 dispatch_request(request->getRequestType(), request);
 122                 break;
 123
 124         case RequestHandlerFlag::ObserverFlag:
 125                 handle_observe_event(request);
 126                 break;
 127     }
 128
 129     return OC_EH_OK;
 130 }
 131
 132 void LightResource::dispatch_request(const std::string& request_type, std::shared_ptr<OCResourceRequest> request)
 133 {
 134  std::cout << "dispatch_request(): " << request_type << '\n';
 135
 136  if("GET" == request_type)
 137   return handle_get_request(request);
 138
 139  if("PUT" == request_type)
 140   return handle_put_request(request);
 141
 142  if("POST" == request_type)
 143   return handle_post_request(request);
 144
 145  if("DELETE" == request_type)
 146   return handle_delete_request(request);
 147
 148  cerr << "entityHandler(): Invalid request type \"" << request_type << "\".\n";
 149 }
 150
 151 void LightResource::handle_get_request(std::shared_ptr<OCResourceRequest> request)
 152 {
 153  cout << "handle_get_request():\n";
 154
 155  const auto query_params_map = request->getQueryParameters();
 156
 157  // ...do any processing of the query here...
 158
 159  // Get a representation of the resource and send it back as a response:
 160  auto pResponse = std::make_shared<OC::OCResourceResponse>();
 161  pResponse->setRequestHandle(request->getRequestHandle());
 162  pResponse->setResourceHandle(request->getResourceHandle());
 163  pResponse->setErrorCode(200);
 164  pResponse->setResponseResult(OC_EH_OK);
 165  pResponse->setResourceRepresentation(getRepresentation());
 166  OCPlatform::sendResponse(pResponse);
 167 }
 168
 169 void LightResource::handle_put_request(std::shared_ptr<OCResourceRequest> request)
 170 {
 171  // Here's how you would get any query parameters:
 172  const auto query_params_map = request->getQueryParameters();
 173  // ...do something with the query parameters (if there were any)...
 174
 175  auto rep = request->getResourceRepresentation();
 176
 177  setRepresentation(rep);
 178
 179  auto pResponse = std::make_shared<OC::OCResourceResponse>();
 180  pResponse->setRequestHandle(request->getRequestHandle());
 181  pResponse->setResourceHandle(request->getResourceHandle());
 182  pResponse->setErrorCode(200);
 183  pResponse->setResponseResult(OC_EH_OK);
 184  pResponse->setResourceRepresentation(getRepresentation());
 185  OCPlatform::sendResponse(pResponse);
 186 }
 187
 188 void LightResource::handle_post_request(std::shared_ptr<OCResourceRequest> request)
 189 {
 190  // ...demo-code...
 191 }
 192
 193 void LightResource::handle_delete_request(std::shared_ptr<OCResourceRequest> request)
 194 {
 195  // ...demo-code...
 196 }
 197
 198 // Set up observation in a separate thread:
 199 void LightResource::handle_observe_event(std::shared_ptr<OCResourceRequest> request)
 200 {
 201  if(observe_thread.joinable())
 202   return;
 203
 204  observe_thread = thread(bind(&LightResource::observe_function, this));
 205  observe_thread.detach();
 206 }
 207
 208
 209
 210 }} // namespace Intel::OCDemo
 211