resource/examples/fridgeclient.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 /// This fridgeclient represents a client trying to discover the associated
  22 /// fridgeserver.  The device resource is the only one available for discovery
  23 /// on the server, so we have to take the fact that we know the device tag
  24 /// to then generate a Resource object
  25
  26 #include <iostream>
  27 #include <stdexcept>
  28 #include <condition_variable>
  29 #include <mutex>
  30 #include <atomic>
  31 #include "OCPlatform.h"
  32 #include "OCApi.h"
  33
  34 using namespace OC;
  35 namespace PH = std::placeholders;
  36
  37 // Option ID for API version and client token
  38 const uint16_t API_VERSION = 2048;
  39 const uint16_t TOKEN = 3000;
  40
  41 static void printUsage()
  42 {
  43     std::cout << "Usage: fridgeclient <0|1>" <<std::endl;
  44     std::cout << "connectivityType: Default IP" << std::endl;
  45     std::cout << "connectivityType 0: IP" << std::endl;
  46 }
  47 class ClientFridge
  48 {
  49     public:
  50     ClientFridge(OCConnectivityType ct): m_callbackCount(0),
  51         m_callsMade(0),m_connectivityType(ct)
  52     {
  53         std::ostringstream requestURI;
  54         requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=intel.fridge";
  55         std::cout << "Fridge Client has started " <<std::endl;
  56         FindCallback f (std::bind(&ClientFridge::foundDevice, this, PH::_1));
  57         OCStackResult result = OCPlatform::findResource(
  58                 "", requestURI.str(), CT_DEFAULT, f);
  59
  60         if(OC_STACK_OK != result)
  61         {
  62             throw new std::runtime_error("Fridge Find Resource Failed");
  63         }
  64
  65         std::cout << "Waiting to discover fridge... "<<std::endl;
  66         {
  67             // we want to block this thread until the client has finished
  68             // its duties, so we block on the CV until we have completed
  69             // what we are looking to do
  70             std::unique_lock<std::mutex> lk(m_mutex);
  71             m_cv.wait(lk, [this]{ return m_callbackCount!=0 && m_callbackCount == m_callsMade;});
  72         }
  73     }
  74
  75     private:
  76     void foundDevice(std::shared_ptr<OCResource> resource)
  77     {
  78         using namespace OC::OCPlatform;
  79         std::string platformDiscoveryURI = "/oic/p";
  80         std::string deviceDiscoveryURI   = "/oic/d";
  81         if(resource && resource->uri() == "/device")
  82         {
  83             std::cout << "Discovered a device object"<<std::endl;
  84             std::cout << "\tHost: "<<resource->host()<<std::endl;
  85             std::cout << "\tURI:  "<<resource->uri() <<std::endl;
  86         }
  87
  88         OCStackResult ret;
  89
  90         std::cout << "Querying for platform information... " << std::endl;
  91
  92         ret = OCPlatform::getPlatformInfo("", platformDiscoveryURI, CT_ADAPTER_IP, NULL);
  93
  94         if (ret == OC_STACK_OK)
  95         {
  96             std::cout << "Get platform information is done." << std::endl;
  97         }
  98         else
  99         {
 100             std::cout << "Get platform information failed." << std::endl;
 101         }
 102
 103         std::cout << "Querying for device information... " << std::endl;
 104
 105         ret = OCPlatform::getDeviceInfo(resource->host(), deviceDiscoveryURI, CT_ADAPTER_IP, NULL);
 106
 107         if (ret == OC_STACK_OK)
 108         {
 109             std::cout << "Getting device information is done." << std::endl;
 110         }
 111         else
 112         {
 113             std::cout << "Getting device information failed." << std::endl;
 114         }
 115
 116         // we have now found a resource, so lets create a few resource objects
 117         // for the other resources that we KNOW are associated with the intel.fridge
 118         // server, and query them.
 119         std::vector<std::string> lightTypes = {"intel.fridge.light"};
 120         std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
 121         OCResource::Ptr light = constructResourceObject(resource->host(),
 122                                 "/light", m_connectivityType, false, lightTypes, ifaces);
 123
 124         if(!light)
 125         {
 126             std::cout << "Error: Light Resource Object construction returned null\n";
 127             return;
 128         }
 129
 130         std::vector<std::string> doorTypes = {"intel.fridge.door"};
 131         OCResource::Ptr leftdoor = constructResourceObject(resource->host(),
 132                                 "/door/left", m_connectivityType, false, doorTypes, ifaces);
 133
 134         if(!leftdoor)
 135         {
 136             std::cout << "Error: Left Door Resource Object construction returned null\n";
 137             return;
 138         }
 139
 140         OCResource::Ptr rightdoor = constructResourceObject(resource->host(),
 141                                 "/door/right", m_connectivityType, false, doorTypes, ifaces);
 142
 143         if(!rightdoor)
 144         {
 145             std::cout << "Error: Right Door Resource Object construction returned null\n";
 146             return;
 147         }
 148
 149         OCResource::Ptr randomdoor = constructResourceObject(resource->host(),
 150                                 "/door/random", m_connectivityType, false, doorTypes, ifaces);
 151         if(!randomdoor)
 152         {
 153             std::cout << "Error: Random Door Resource Object construction returned null\n";
 154             return;
 155         }
 156
 157         // Set header options with API version and token
 158         HeaderOptions headerOptions;
 159         try
 160         {
 161             // Set API version and client token
 162             HeaderOption::OCHeaderOption apiVersion(API_VERSION, "v.1.0");
 163             HeaderOption::OCHeaderOption clientToken(TOKEN, "21ae43gf");
 164             headerOptions.push_back(apiVersion);
 165             headerOptions.push_back(clientToken);
 166         }
 167         catch(OCException& e)
 168         {
 169             std::cout << "Error creating HeaderOption: " << e.what() << std::endl;
 170         }
 171
 172
 173         // Setting header options will send above options in all requests
 174         // Header options are set per resource.
 175         // Below, header options are set only for device resource
 176         resource->setHeaderOptions(headerOptions);
 177
 178         ++m_callsMade;
 179         resource->get(QueryParamsMap(), GetCallback(
 180                 std::bind(&ClientFridge::getResponse, this, "Device", PH::_1,
 181                     PH::_2, PH::_3, resource, 0)
 182                 ));
 183         ++m_callsMade;
 184         light->get(QueryParamsMap(), GetCallback(
 185                 std::bind(&ClientFridge::getResponse, this, "Fridge Light", PH::_1,
 186                     PH::_2, PH::_3, light, 1)
 187                 ));
 188         ++m_callsMade;
 189         leftdoor->get(QueryParamsMap(), GetCallback(
 190                 std::bind(&ClientFridge::getResponse, this, "Left Door", PH::_1,
 191                     PH::_2, PH::_3, leftdoor, 2)
 192                 ));
 193         ++m_callsMade;
 194         rightdoor->get(QueryParamsMap(), GetCallback(
 195                 std::bind(&ClientFridge::getResponse, this, "Right Door", PH::_1,
 196                     PH::_2, PH::_3, rightdoor, 3)
 197                 ));
 198         ++m_callsMade;
 199         randomdoor->get(QueryParamsMap(), GetCallback(
 200                 std::bind(&ClientFridge::getResponse, this, "Random Door", PH::_1,
 201                     PH::_2, PH::_3, randomdoor, 4)
 202                 ));
 203         ++m_callsMade;
 204         resource->deleteResource(DeleteCallback(
 205                 std::bind(&ClientFridge::deleteResponse, this, "Device", PH::_1,
 206                     PH::_2, resource, 0)
 207                 ));
 208     }
 209
 210     // Note that resourceName, resource, and getId are all bound via the std::bind mechanism.
 211     // it is possible to attach ANY arbitrary data to do whatever you would like here.  It may,
 212     // however be a better fit to wrap each call in an object so a fuller context (and additional
 213     // requests) can be easily made inside of a simple context
 214     void getResponse(const std::string& resourceName, const HeaderOptions& headerOptions,
 215                 const OCRepresentation& rep, const int eCode, OCResource::Ptr resource, int getId)
 216     {
 217         std::cout << "Got a response from get from the " << resourceName << std::endl;
 218         std::cout << "Get ID is "<<getId<<" and resource URI is " << resource->uri() << std::endl;
 219         std::cout << "Get eCode is "<< eCode << std::endl;
 220         std::cout << "OCRepresentation uri is " << rep.getUri() << std::endl;
 221
 222         printHeaderOptions(headerOptions);
 223
 224         std::cout << "The Attribute Data is: "<<std::endl;
 225
 226         switch(getId)
 227         {
 228             case 0:
 229                 {
 230                     // Get on device
 231                     std::string name;
 232                     rep.getValue("device_name", name);
 233                     std::cout << "Name of device: "<< name << std::endl;
 234                     break;
 235                 }
 236             case 1:
 237                 {
 238                     bool isOn = false;
 239                     rep.getValue("on",isOn);
 240                     std::cout<<"The fridge light is "<< ((isOn)?"":"not ") <<"on"<<std::endl;
 241                 }
 242                 break;
 243             case 2:
 244             case 3:
 245                 {
 246                     bool isOpen = false;
 247                     std::string side;
 248                     rep.getValue("open", isOpen);
 249                     rep.getValue("side", side);
 250                     std::cout << "Door is "<<isOpen<<" and is on the "<<side<<std::endl;
 251                 }
 252                 break;
 253             case 4:
 254                 {
 255                     // Get on random resource called.
 256                     std::string name;
 257                     rep.getValue("device_name", name);
 258                     std::cout << "Name of fridge: "<< name << std::endl;
 259                     break;
 260                 }
 261         }
 262         ++m_callbackCount;
 263
 264         if(m_callbackCount == m_callsMade)
 265         {
 266             m_cv.notify_all();
 267         }
 268     }
 269
 270     //Callback function to handle response for deleteResource call.
 271     void deleteResponse(const std::string& resourceName, const HeaderOptions& headerOptions,
 272                 const int /*eCode*/, OCResource::Ptr resource, int deleteId)
 273     {
 274         std::cout << "Got a response from delete from the "<< resourceName << std::endl;
 275         std::cout << "Delete ID is "<<deleteId<<" and resource URI is "<<resource->uri()<<std::endl;
 276         printHeaderOptions(headerOptions);
 277
 278         ++m_callbackCount;
 279
 280         if(m_callbackCount == m_callsMade)
 281         {
 282             m_cv.notify_all();
 283         }
 284     }
 285
 286     //Function to print the headerOptions received from the server
 287     void printHeaderOptions(const HeaderOptions& headerOptions)
 288     {
 289         for (auto it = headerOptions.begin(); it != headerOptions.end(); ++it)
 290         {
 291             if(it->getOptionID() == API_VERSION)
 292             {
 293                 std::cout << "Server API version in GET response: " <<
 294                         it->getOptionData() << std::endl;
 295             }
 296         }
 297     }
 298
 299     std::mutex m_mutex;
 300     std::condition_variable m_cv;
 301     std::atomic<int> m_callbackCount;
 302     std::atomic<int> m_callsMade;
 303     OCConnectivityType m_connectivityType;
 304 };
 305
 306 int main(int argc, char* argv[])
 307 {
 308     OCConnectivityType connectivityType = CT_ADAPTER_IP;
 309     if(argc == 2)
 310     {
 311         try
 312         {
 313             std::size_t inputValLen;
 314             int optionSelected = std::stoi(argv[1], &inputValLen);
 315
 316             if(inputValLen == strlen(argv[1]))
 317             {
 318                 if(optionSelected == 0)
 319                 {
 320                     std::cout << "Using IP."<< std::endl;
 321                     connectivityType = CT_ADAPTER_IP;
 322                 }
 323                 else
 324                 {
 325                     std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
 326                     printUsage();
 327                 }
 328             }
 329             else
 330             {
 331                 std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
 332             }
 333         }
 334         catch(std::exception&)
 335         {
 336             std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
 337         }
 338     }
 339     else
 340     {
 341         printUsage();
 342         std::cout << "Default input argument. Using IP as connectivity type" << std::endl;
 343     }
 344
 345     PlatformConfig cfg
 346     {
 347         ServiceType::InProc,
 348         ModeType::Client,
 349         "0.0.0.0",
 350         0,
 351         QualityOfService::LowQos
 352     };
 353
 354     OCPlatform::Configure(cfg);
 355     ClientFridge cf(connectivityType);
 356     return 0;
 357 }
 358