resource/examples/roomclient.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH 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 // OCClient.cpp : Defines the entry point for the console application.
  22 //
  23 #include <string>
  24 #include <cstdlib>
  25 #include <pthread.h>
  26 #include <mutex>
  27 #include <condition_variable>
  28
  29 #include "OCPlatform.h"
  30 #include "OCApi.h"
  31
  32 using namespace OC;
  33
  34 const int SUCCESS_RESPONSE = 0;
  35 std::shared_ptr<OCResource> curResource;
  36 std::mutex resourceLock;
  37
  38 int observe_count()
  39 {
  40     static int oc = 0;
  41     return ++oc;
  42 }
  43
  44 static void printUsage()
  45 {
  46     std::cout << "Usage roomclient <0|1>" << std::endl;
  47     std::cout<<"connectivityType: Default" << std::endl;
  48     std::cout << "connectivityType 0: IP" << std::endl;
  49 }
  50 // Forward declaration
  51 void putRoomRepresentation(std::shared_ptr<OCResource> resource);
  52 void onPut(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode);
  53
  54 void printRoomRepresentation(const OCRepresentation& rep)
  55 {
  56     std::cout << "\tResource URI: " << rep.getUri() << std::endl;
  57
  58     if(rep.hasAttribute("name"))
  59     {
  60         std::cout << "\tRoom name: " << rep.getValue<std::string>("name") << std::endl;
  61     }
  62
  63     std::vector<OCRepresentation> children = rep.getChildren();
  64
  65     for(auto oit = children.begin(); oit != children.end(); ++oit)
  66     {
  67         std::cout << "\t\tChild Resource URI: " << oit->getUri() << std::endl;
  68         if(oit->getUri().find("light") != std::string::npos)
  69         {
  70             if(oit->hasAttribute("state") && oit->hasAttribute("color"))
  71             {
  72                 std::cout << "\t\tstate:" << oit->getValue<bool>("state")  << std::endl;
  73                 std::cout << "\t\tcolor:" << oit->getValue<int>("color")  << std::endl;
  74             }
  75         }
  76         else if(oit->getUri().find("fan") != std::string::npos)
  77         {
  78             if(oit->hasAttribute("state") && oit->hasAttribute("speed"))
  79             {
  80                 std::cout << "\t\tstate:" << oit->getValue<bool>("state") << std::endl;
  81                 std::cout << "\t\tspeed:" << oit->getValue<int>("speed") << std::endl;
  82             }
  83         }
  84     }
  85 }
  86
  87 // callback handler on GET request
  88 void onGet(const HeaderOptions& /*headerOptions*/,
  89         const OCRepresentation& rep, const int eCode)
  90 {
  91     if(eCode == SUCCESS_RESPONSE)
  92     {
  93         std::cout << "GET request was successful" << std::endl;
  94
  95         printRoomRepresentation(rep);
  96
  97         putRoomRepresentation(curResource);
  98     }
  99     else
 100     {
 101         std::cout << "onGET Response error: " << eCode << std::endl;
 102         std::exit(-1);
 103     }
 104 }
 105
 106 void onGet1(const HeaderOptions& /*headerOptions*/,
 107         const OCRepresentation& rep, const int eCode)
 108 {
 109     if(eCode == SUCCESS_RESPONSE)
 110     {
 111         std::cout << "GET request was successful" << std::endl;
 112
 113         printRoomRepresentation(rep);
 114     }
 115     else
 116     {
 117         std::cout << "onGET Response error: " << eCode << std::endl;
 118         std::exit(-1);
 119     }
 120 }
 121
 122 // Local function to get representation of room resource
 123 void getRoomRepresentation(std::shared_ptr<OCResource> resource,
 124                             std::string interface, GetCallback getCallback)
 125 {
 126     if(resource)
 127     {
 128         std::cout << "Getting room representation on: "<< interface << std::endl;
 129
 130         resource->get("core.room", interface, QueryParamsMap(), getCallback);
 131     }
 132 }
 133
 134 // Local function to put a different state for this resource
 135 void putRoomRepresentation(std::shared_ptr<OCResource> resource)
 136 {
 137     if(resource)
 138     {
 139         OCRepresentation rep;
 140         std::cout << "Putting room representation on: " << BATCH_INTERFACE << std::endl;
 141
 142         bool state = true;
 143         int speed = 10;
 144         rep.setValue("state", state);
 145         rep.setValue("speed", speed);
 146
 147         // Invoke resource's pit API with attribute map, query map and the callback parameter
 148         resource->put("core.room", BATCH_INTERFACE, rep, QueryParamsMap(), &onPut);
 149     }
 150 }
 151
 152 // callback handler on PUT request
 153 void onPut(const HeaderOptions& /*headerOptions*/, const OCRepresentation& rep, const int eCode)
 154 {
 155     if(eCode == SUCCESS_RESPONSE)
 156     {
 157         std::cout << "PUT request was successful" << std::endl;
 158
 159         printRoomRepresentation(rep);
 160
 161         getRoomRepresentation(curResource, DEFAULT_INTERFACE, onGet1);
 162     }
 163     else
 164     {
 165         std::cout << "onPut Response error: " << eCode << std::endl;
 166         std::exit(-1);
 167     }
 168 }
 169
 170 // Callback to found resources
 171 void foundResource(std::shared_ptr<OCResource> resource)
 172 {
 173     std::lock_guard<std::mutex> lock(resourceLock);
 174     if(curResource)
 175     {
 176         std::cout << "Found another resource, ignoring"<<std::endl;
 177         return;
 178     }
 179
 180     std::string resourceURI;
 181     std::string hostAddress;
 182     try
 183     {
 184         // Do some operations with resource object.
 185         if(resource)
 186         {
 187             std::cout<<"DISCOVERED Resource:"<<std::endl;
 188             // Get the resource URI
 189             resourceURI = resource->uri();
 190             std::cout << "\tURI of the resource: " << resourceURI << std::endl;
 191
 192             // Get the resource host address
 193             hostAddress = resource->host();
 194             std::cout << "\tHost address of the resource: " << hostAddress << std::endl;
 195
 196             // Get the resource types
 197             std::cout << "\tList of resource types: " << std::endl;
 198             for(auto &resourceTypes : resource->getResourceTypes())
 199             {
 200                 std::cout << "\t\t" << resourceTypes << std::endl;
 201             }
 202
 203             // Get the resource interfaces
 204             std::cout << "\tList of resource interfaces: " << std::endl;
 205             for(auto &resourceInterfaces : resource->getResourceInterfaces())
 206             {
 207                 std::cout << "\t\t" << resourceInterfaces << std::endl;
 208             }
 209
 210             if(resourceURI == "/a/room")
 211             {
 212                 curResource = resource;
 213                 // Call a local function which will internally invoke get API on the resource pointer
 214                 getRoomRepresentation(resource, BATCH_INTERFACE, onGet);
 215             }
 216         }
 217         else
 218         {
 219             // Resource is invalid
 220             std::cout << "Resource is invalid" << std::endl;
 221         }
 222
 223     }
 224     catch(std::exception& e)
 225     {
 226         std::cerr << "Exception caught in Found Resource: "<< e.what() <<std::endl;
 227     }
 228 }
 229
 230 int main(int argc, char* argv[]) {
 231
 232     std::ostringstream requestURI;
 233
 234     OCConnectivityType connectivityType = CT_ADAPTER_IP;
 235     if(argc == 2)
 236     {
 237         try
 238         {
 239             std::size_t inputValLen;
 240             int optionSelected = std::stoi(argv[1], &inputValLen);
 241
 242             if(inputValLen == strlen(argv[1]))
 243             {
 244                 if(optionSelected == 0)
 245                 {
 246                     std::cout << "Using IP."<< std::endl;
 247                     connectivityType = CT_ADAPTER_IP;
 248                 }
 249                 else
 250                 {
 251                     std::cout << "Invalid connectivity type selected. Using default IP"<< std::endl;
 252                 }
 253             }
 254             else
 255             {
 256                 std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
 257             }
 258         }
 259         catch(std::exception&)
 260         {
 261             std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
 262         }
 263     }
 264     else
 265     {
 266         std::cout << "Default input argument. Using IP as Default connectivity type" << std::endl;
 267         printUsage();
 268     }
 269
 270     // Create PlatformConfig object
 271     PlatformConfig cfg {
 272         OC::ServiceType::InProc,
 273         OC::ModeType::Client,
 274         "0.0.0.0",
 275         0,
 276         OC::QualityOfService::LowQos
 277     };
 278
 279     OCPlatform::Configure(cfg);
 280
 281     try
 282     {
 283         // Find all resources
 284         requestURI << OC_RSRVD_WELL_KNOWN_URI;
 285
 286         OCPlatform::findResource("", requestURI.str(), connectivityType, &foundResource);
 287         std::cout<< "Finding Resource... " <<std::endl;
 288
 289         // A condition variable will free the mutex it is given, then do a non-
 290         // intensive block until 'notify' is called on it.  In this case, since we
 291         // don't ever call cv.notify, this should be a non-processor intensive version
 292         // of while(true);
 293         std::mutex blocker;
 294         std::condition_variable cv;
 295         std::unique_lock<std::mutex> lock(blocker);
 296         cv.wait(lock);
 297
 298     }catch(OCException& e)
 299     {
 300         oclog() << "Exception in main: "<< e.what();
 301     }
 302
 303     return 0;
 304 }
 305
 306