6b3dd42b0afb461f80e3e155ba8a5ac1f7de7c0a
[platform/upstream/iotivity.git] / 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