service/protocol-plugin/plugins/mqtt-fan/src/fanserver.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 ///
  22 /// This sample provides steps to define an interface for a resource
  23 /// (properties and methods) and host this resource on the server.
  24 ///
  25
  26 #include <functional>
  27 #include <pthread.h>
  28 #include <cpluff.h>
  29
  30 #include "OCPlatform.h"
  31 #include "OCApi.h"
  32 #include "../lib/mosquitto.h"
  33 #include "fanserver.h"
  34
  35 #include <time.h>
  36
  37
  38 using namespace OC;
  39 using namespace std;
  40 namespace PH = std::placeholders;
  41
  42 time_t timer;                // Define the timer
  43 struct tm *tblock;           // Define a structure for time block
  44
  45
  46 int gObservation = 0;
  47 void *ChangeFanRepresentation (void *param);
  48 void *handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest);
  49
  50 // Specifies where to notify all observers or list of observers
  51 // false: notifies all observers
  52 // true: notifies list of observers
  53 bool isListOfObservers = false;
  54
  55 // Specifies secure or non-secure
  56 // false: non-secure resource
  57 // true: secure resource
  58 bool isSecure = false;
  59
  60 /// Specifies whether Entity handler is going to do slow response or not
  61 bool isSlowResponse = false;
  62
  63 // Forward declaring the entityHandler
  64 /// This class represents a single resource named 'fanResource'. This resource has
  65 /// two simple properties named 'state' and 'power'
  66 typedef struct plugin_data_t plugin_data_t;
  67
  68 struct plugin_data_t
  69 {
  70     cp_context_t *ctx;
  71     pthread_t m_thread;                                 // 2
  72     void *str;
  73     bool flag;
  74 };
  75
  76
  77 class FanResource
  78 {
  79     public:
  80         /// Access this property from a TB client
  81         std::string m_name;
  82         bool m_state;
  83         int m_power;
  84         int m_health;
  85         std::string m_fanUri;
  86         OCResourceHandle m_resourceHandle;
  87         OCRepresentation m_fanRep;
  88         ObservationIds m_interestedObservers;
  89
  90     public:
  91         /// Constructor
  92         FanResource(): m_name("John's fan"), m_state(false), m_power(0), m_fanUri("/a/fan")
  93         {
  94             // Initialize representation
  95             m_fanRep.setUri(m_fanUri);
  96
  97             m_fanRep.setValue("state", m_state);
  98             m_fanRep.setValue("power", m_power);
  99             m_fanRep.setValue("name", m_name);
 100         }
 101
 102
 103         /* Note that this does not need to be a member function: for classes you do not have
 104         access to, you can accomplish this with a free function: */
 105
 106         /// This function internally calls registerResource API.
 107         void createResource()
 108         {
 109             std::string resourceURI = m_fanUri; // URI of the resource
 110             std::string resourceTypeName = "core.fan"; // resource type name. In this case, it is fan
 111             std::string resourceInterface = DEFAULT_INTERFACE; // resource interface.
 112
 113             // OCResourceProperty is defined ocstack.h
 114             uint8_t resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
 115
 116             EntityHandler cb = std::bind(&FanResource::entityHandler, this, PH::_1);
 117
 118             // This will internally create and register the resource.
 119             OCStackResult result = OCPlatform::registerResource(
 120                                        m_resourceHandle, resourceURI, resourceTypeName,
 121                                        resourceInterface, cb, resourceProperty);
 122
 123             if (OC_STACK_OK != result)
 124             {
 125                 cout << "Resource creation was unsuccessful\n";
 126             }
 127         }
 128
 129         OCStackResult createResource1()
 130         {
 131             std::string resourceURI = "/a/fan1"; // URI of the resource
 132             std::string resourceTypeName = "core.fan"; // resource type name. In this case, it is fan
 133             std::string resourceInterface = DEFAULT_INTERFACE; // resource interface.
 134
 135             // OCResourceProperty is defined ocstack.h
 136             uint8_t resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
 137
 138             EntityHandler cb = std::bind(&FanResource::entityHandler, this, PH::_1);
 139
 140             OCResourceHandle resHandle;
 141
 142             // This will internally create and register the resource.
 143             OCStackResult result = OCPlatform::registerResource(
 144                                        resHandle, resourceURI, resourceTypeName,
 145                                        resourceInterface, cb, resourceProperty);
 146
 147             if (OC_STACK_OK != result)
 148             {
 149                 cout << "Resource creation was unsuccessful\n";
 150             }
 151
 152             return result;
 153         }
 154
 155         OCResourceHandle getHandle()
 156         {
 157             return m_resourceHandle;
 158         }
 159
 160         // Puts representation.
 161         // Gets values from the representation and
 162         // updates the internal state
 163         void put(OCRepresentation &rep)
 164         {
 165             try
 166             {
 167                 if (rep.getValue("state", m_state))
 168                 {
 169                     cout << "\t\t\t\t" << "state: " << m_state << endl;
 170                 }
 171                 else
 172                 {
 173                     cout << "\t\t\t\t" << "state not found in the representation" << endl;
 174                 }
 175
 176                 if (rep.getValue("power", m_power))
 177                 {
 178                     cout << "\t\t\t\t" << "power: " << m_power << endl;
 179                 }
 180                 else
 181                 {
 182                     cout << "\t\t\t\t" << "power not found in the representation" << endl;
 183                 }
 184             }
 185             catch (exception &e)
 186             {
 187                 cout << e.what() << endl;
 188             }
 189
 190         }
 191
 192         // Post representation.
 193         // Post can create new resource or simply act like put.
 194         // Gets values from the representation and
 195         // updates the internal state
 196         OCRepresentation post(OCRepresentation &rep)
 197         {
 198             static int first = 1;
 199
 200             // for the first time it tries to create a resource
 201             if (first)
 202             {
 203                 first = 0;
 204
 205                 if (OC_STACK_OK == createResource1())
 206                 {
 207                     OCRepresentation rep1;
 208                     rep1.setValue("createduri", std::string("/a/fan1"));
 209
 210                     return rep1;
 211                 }
 212             }
 213
 214             // from second time onwards it just puts
 215             put(rep);
 216             return get();
 217         }
 218
 219
 220         // gets the updated representation.
 221         // Updates the representation with latest internal state before
 222         // sending out.
 223         OCRepresentation get()
 224         {
 225             m_fanRep.setValue("state", m_state);
 226             m_fanRep.setValue("power", m_power);
 227
 228             return m_fanRep;
 229         }
 230
 231
 232         void addType(const std::string &type) const
 233         {
 234             OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
 235             if (OC_STACK_OK != result)
 236             {
 237                 cout << "Binding TypeName to Resource was unsuccessful\n";
 238             }
 239         }
 240
 241         void addInterface(const std::string &interface) const
 242         {
 243             OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
 244             if (OC_STACK_OK != result)
 245             {
 246                 cout << "Binding TypeName to Resource was unsuccessful\n";
 247             }
 248         }
 249
 250     private:
 251         // This is just a sample implementation of entity handler.
 252         // Entity handler can be implemented in several ways by the manufacturer
 253         OCEntityHandlerResult entityHandler(std::shared_ptr<OCResourceRequest> request)
 254         {
 255             cout << "\tIn Server CPP entity handler:\n";
 256             OCEntityHandlerResult ehResult = OC_EH_ERROR;
 257             if (request)
 258             {
 259                 // Get the request type and request flag
 260                 std::string requestType = request->getRequestType();
 261                 int requestFlag = request->getRequestHandlerFlag();
 262
 263                 if (requestFlag & RequestHandlerFlag::InitFlag)
 264                 {
 265                     cout << "\t\trequestFlag : Init\n";
 266
 267                     // entity handler to perform resource initialization operations
 268                 }
 269                 if (requestFlag & RequestHandlerFlag::RequestFlag)
 270                 {
 271                     cout << "\t\trequestFlag : Request   ===  Handle by FanServer\n";
 272                     auto pResponse = std::make_shared<OC::OCResourceResponse>();
 273                     pResponse->setRequestHandle(request->getRequestHandle());
 274                     pResponse->setResourceHandle(request->getResourceHandle());
 275
 276                     // If the request type is GET
 277                     if (requestType == "GET")
 278                     {
 279                         cout << "\t\t\trequestType : GET\n";
 280                         if (isSlowResponse) // Slow response case
 281                         {
 282                             static int startedThread = 0;
 283                             if (!startedThread)
 284                             {
 285                                 std::thread t(handleSlowResponse, (void *)this, request);
 286                                 startedThread = 1;
 287                                 t.detach();
 288                             }
 289                             ehResult = OC_EH_SLOW;
 290                         }
 291                         else // normal response case.
 292                         {
 293                             pResponse->setErrorCode(200);
 294                             pResponse->setResponseResult(OC_EH_OK);
 295                             pResponse->setResourceRepresentation(get());
 296                             if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 297                             {
 298                                 ehResult = OC_EH_OK;
 299                             }
 300                         }
 301                     }
 302                     else if (requestType == "PUT")
 303                     {
 304                         cout << "\t\t\trequestType : PUT\n";
 305                         OCRepresentation rep = request->getResourceRepresentation();
 306
 307                         // Do related operations related to PUT request
 308                         // Update the fanResource
 309                         put(rep);
 310                         pResponse->setErrorCode(200);
 311                         pResponse->setResponseResult(OC_EH_OK);
 312                         pResponse->setResourceRepresentation(get());
 313                         if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 314                         {
 315                             ehResult = OC_EH_OK;
 316                         }
 317                     }
 318                     else if (requestType == "POST")
 319                     {
 320                         cout << "\t\t\trequestType : POST\n";
 321
 322                         OCRepresentation rep = request->getResourceRepresentation();
 323
 324                         // Do related operations related to POST request
 325                         OCRepresentation rep_post = post(rep);
 326                         pResponse->setResourceRepresentation(rep_post);
 327                         pResponse->setErrorCode(200);
 328                         if (rep_post.hasAttribute("createduri"))
 329                         {
 330                             pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
 331                             pResponse->setNewResourceUri(rep_post.getValue<std::string>("createduri"));
 332                         }
 333
 334                         if (OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 335                         {
 336                             ehResult = OC_EH_OK;
 337                         }
 338                     }
 339                     else if (requestType == "DELETE")
 340                     {
 341                         // DELETE request operations
 342                     }
 343                 }
 344
 345                 if (requestFlag & RequestHandlerFlag::ObserverFlag)
 346                 {
 347                     ObservationInfo observationInfo = request->getObservationInfo();
 348                     if (ObserveAction::ObserveRegister == observationInfo.action)
 349                     {
 350                         m_interestedObservers.push_back(observationInfo.obsId);
 351                     }
 352                     else if (ObserveAction::ObserveUnregister == observationInfo.action)
 353                     {
 354                         m_interestedObservers.erase(std::remove(
 355                                                         m_interestedObservers.begin(),
 356                                                         m_interestedObservers.end(),
 357                                                         observationInfo.obsId),
 358                                                     m_interestedObservers.end());
 359                     }
 360
 361                     pthread_t threadId;
 362
 363                     cout << "\t\trequestFlag : Observer\n";
 364                     gObservation = 1;
 365                     static int startedThread = 0;
 366
 367                     // Observation happens on a different thread in ChangeFanRepresentation function.
 368                     // If we have not created the thread already, we will create one here.
 369                     if (!startedThread)
 370                     {
 371                         pthread_create (&threadId, NULL, ChangeFanRepresentation, (void *)this);
 372                         startedThread = 1;
 373                     }
 374                     ehResult = OC_EH_OK;
 375                 }
 376             }
 377             else
 378             {
 379                 std::cout << "Request invalid" << std::endl;
 380             }
 381
 382             return ehResult;
 383         }
 384 };
 385
 386 // Create the instance of the resource class (in this case instance of class 'FanResource').
 387 struct mosquitto *myMosquitto;
 388
 389 // ChangeFanRepresentaion is an observation function,
 390 // which notifies any changes to the resource to stack
 391 // via notifyObservers
 392 void *ChangeFanRepresentation (void *param)
 393 {
 394     FanResource *fanPtr = (FanResource *) param;
 395
 396     // This function continuously monitors for the changes
 397     while (1)
 398     {
 399         sleep (5);
 400
 401         if (gObservation)
 402         {
 403             // If under observation if there are any changes to the fan resource
 404             // we call notifyObservors
 405             //
 406             // For demostration we are changing the power value and notifying.
 407             fanPtr->m_power += 10;
 408
 409             cout << "\nPower updated to : " << fanPtr->m_power << endl;
 410             cout << "Notifying observers with resource handle: " << fanPtr->getHandle() << endl;
 411
 412             OCStackResult result = OC_STACK_OK;
 413
 414             if (isListOfObservers)
 415             {
 416                 std::shared_ptr<OCResourceResponse> resourceResponse(new OCResourceResponse());
 417
 418                 resourceResponse->setErrorCode(200);
 419                 resourceResponse->setResourceRepresentation(fanPtr->get(), DEFAULT_INTERFACE);
 420
 421                 result = OCPlatform::notifyListOfObservers(  fanPtr->getHandle(),
 422                          fanPtr->m_interestedObservers,
 423                          resourceResponse);
 424             }
 425             else
 426             {
 427                 result = OCPlatform::notifyAllObservers(fanPtr->getHandle());
 428             }
 429
 430             if (OC_STACK_NO_OBSERVERS == result)
 431             {
 432                 cout << "No More observers, stopping notifications" << endl;
 433                 gObservation = 0;
 434             }
 435         }
 436     }
 437
 438     return NULL;
 439 }
 440
 441 void *handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest)
 442 {
 443     // This function handles slow response case
 444     FanResource *fanPtr = (FanResource *) param;
 445     // Induce a case for slow response by using sleep
 446     std::cout << "SLOW response" << std::endl;
 447     sleep (10);
 448
 449     auto pResponse = std::make_shared<OC::OCResourceResponse>();
 450     pResponse->setRequestHandle(pRequest->getRequestHandle());
 451     pResponse->setResourceHandle(pRequest->getResourceHandle());
 452     pResponse->setResourceRepresentation(fanPtr->get());
 453     pResponse->setErrorCode(200);
 454     pResponse->setResponseResult(OC_EH_OK);
 455
 456     // Set the slow response flag back to false
 457     isSlowResponse = false;
 458     OCPlatform::sendResponse(pResponse);
 459     return NULL;
 460 }
 461
 462
 463 //int start_fanserver(void*)                // 1
 464 void *start_fanserver(void *d)      // 2
 465 {
 466     // Create PlatformConfig object
 467     PlatformConfig cfg
 468     {
 469         OC::ServiceType::InProc,
 470         OC::ModeType::Both,
 471         "0.0.0.0", // By setting to "0.0.0.0", it binds to all available interfaces
 472         0,         // Uses randomly available port
 473         OC::QualityOfService::LowQos
 474     };
 475
 476     OCPlatform::Configure(cfg);
 477
 478     printf("start_fanserver [mosquitto] Null\n");
 479     try
 480     {
 481         FanResource myFanResource;
 482         mosquitto_lib_init();
 483         myMosquitto = mosquitto_new("MQTT plug-in", true, NULL);
 484         if (!myMosquitto)
 485         {
 486             printf("[mosquitto] Null\n");
 487             printf("You need to install mqtt broker\n");
 488         }
 489         else
 490         {
 491             printf("Mosquitto is working\n");
 492         }
 493
 494         mosquitto_connect(myMosquitto, "127.0.0.1", 1883, 60);
 495         printf("Mosquitto Connection is done\n");
 496         myFanResource.createResource();
 497         // Get time of day
 498         timer = time(NULL);
 499         // Converts date/time to a structure
 500         tblock = localtime(&timer);
 501         // Output ASCII data/time
 502         printf("FanReousrce reigishter time is: %s", asctime(tblock));
 503         // Perform app tasks
 504         while (true)
 505         {
 506             // some tasks
 507         }
 508     }
 509     catch (OCException e)
 510     {
 511         //log(e.what());
 512     }
 513     // No explicit call to stop the platform.
 514     // When OCPlatform destructor is invoked, internally we do platform cleanup
 515     mosquitto_destroy(myMosquitto);
 516
 517     mosquitto_lib_cleanup();
 518     printf("start_fanserver finish\n");
 519     pthread_exit((void *)0);
 520 }