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, std::placeholders::_2),
  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, std::shared_ptr<OCResourceResponse> response)
 103 {
 104     if(!request)
 105      {
 106         cerr << "entityHandler(): Received invalid request object.\n";
 107         return OC_EH_ERROR;
 108      }
 109
 110     if(!response)
 111      {
 112         cerr << "entityHandler(): Received invalid response object.\n";
 113         return OC_EH_ERROR;
 114      }
 115
 116     switch(request->getRequestHandlerFlag())
 117     {
 118         default:
 119                 cerr << "entityHandler(): invalid request flag\n";
 120                 break;
 121
 122         case RequestHandlerFlag::InitFlag:
 123                 cerr << "entityHandler(): Initialization requested.\n";
 124                 break;
 125
 126         case RequestHandlerFlag::RequestFlag:
 127                 dispatch_request(request->getRequestType(), request, response);
 128                 break;
 129
 130         case RequestHandlerFlag::ObserverFlag:
 131                 handle_observe_event(request, response);
 132                 break;
 133     }
 134
 135     return OC_EH_OK;
 136 }
 137
 138 void LightResource::dispatch_request(const std::string& request_type, std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 139 {
 140  std::cout << "dispatch_request(): " << request_type << '\n';
 141
 142  if("GET" == request_type)
 143   return handle_get_request(request, response);
 144
 145  if("PUT" == request_type)
 146   return handle_put_request(request, response);
 147
 148  if("POST" == request_type)
 149   return handle_post_request(request, response);
 150
 151  if("DELETE" == request_type)
 152   return handle_delete_request(request, response);
 153
 154  cerr << "entityHandler(): Invalid request type \"" << request_type << "\".\n";
 155 }
 156
 157 void LightResource::handle_get_request(std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 158 {
 159  cout << "handle_get_request():\n";
 160
 161  const auto query_params_map = request->getQueryParameters();
 162
 163  // ...do any processing of the query here...
 164
 165  // Get a representation of the resource and send it back as a response:
 166  response->setErrorCode(200);
 167  response->setResourceRepresentation(getRepresentation());
 168 }
 169
 170 void LightResource::handle_put_request(std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 171 {
 172  // Here's how you would get any query parameters:
 173  const auto query_params_map = request->getQueryParameters();
 174  // ...do something with the query parameters (if there were any)...
 175
 176  auto rep = request->getResourceRepresentation();
 177
 178  setRepresentation(rep);
 179
 180  if(!response)
 181   return;
 182
 183  response->setErrorCode(200);
 184  response->setResourceRepresentation(getRepresentation());
 185 }
 186
 187 void LightResource::handle_post_request(std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 188 {
 189  // ...demo-code...
 190 }
 191
 192 void LightResource::handle_delete_request(std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 193 {
 194  // ...demo-code...
 195 }
 196
 197 // Set up observation in a separate thread:
 198 void LightResource::handle_observe_event(std::shared_ptr<OCResourceRequest> request, std::shared_ptr<OCResourceResponse> response)
 199 {
 200  if(observe_thread.joinable())
 201   return;
 202
 203  observe_thread = thread(bind(&LightResource::observe_function, this));
 204  observe_thread.detach();
 205 }
 206
 207
 208
 209 }} // namespace Intel::OCDemo
 210