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         if(resource && resource->uri() == "/device")
  80         {
  81             std::cout << "Discovered a device object"<<std::endl;
  82             std::cout << "\tHost: "<<resource->host()<<std::endl;
  83             std::cout << "\tURI:  "<<resource->uri() <<std::endl;
  84         }
  85
  86         // we have now found a resource, so lets create a few resource objects
  87         // for the other resources that we KNOW are associated with the intel.fridge
  88         // server, and query them.
  89         std::vector<std::string> lightTypes = {"intel.fridge.light"};
  90         std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
  91         OCResource::Ptr light = constructResourceObject(resource->host(),
  92                                 "/light", m_connectivityType, false, lightTypes, ifaces);
  93
  94         if(!light)
  95         {
  96             std::cout << "Error: Light Resource Object construction returned null\n";
  97             return;
  98         }
  99
 100         std::vector<std::string> doorTypes = {"intel.fridge.door"};
 101         OCResource::Ptr leftdoor = constructResourceObject(resource->host(),
 102                                 "/door/left", m_connectivityType, false, doorTypes, ifaces);
 103
 104         if(!leftdoor)
 105         {
 106             std::cout << "Error: Left Door Resource Object construction returned null\n";
 107             return;
 108         }
 109
 110         OCResource::Ptr rightdoor = constructResourceObject(resource->host(),
 111                                 "/door/right", m_connectivityType, false, doorTypes, ifaces);
 112
 113         if(!rightdoor)
 114         {
 115             std::cout << "Error: Right Door Resource Object construction returned null\n";
 116             return;
 117         }
 118
 119         OCResource::Ptr randomdoor = constructResourceObject(resource->host(),
 120                                 "/door/random", m_connectivityType, false, doorTypes, ifaces);
 121         if(!randomdoor)
 122         {
 123             std::cout << "Error: Random Door Resource Object construction returned null\n";
 124             return;
 125         }
 126
 127         // Set header options with API version and token
 128         HeaderOptions headerOptions;
 129         try
 130         {
 131             // Set API version and client token
 132             HeaderOption::OCHeaderOption apiVersion(API_VERSION, "v.1.0");
 133             HeaderOption::OCHeaderOption clientToken(TOKEN, "21ae43gf");
 134             headerOptions.push_back(apiVersion);
 135             headerOptions.push_back(clientToken);
 136         }
 137         catch(OCException& e)
 138         {
 139             std::cout << "Error creating HeaderOption: " << e.what() << std::endl;
 140         }
 141
 142
 143         // Setting header options will send above options in all requests
 144         // Header options are set per resource.
 145         // Below, header options are set only for device resource
 146         resource->setHeaderOptions(headerOptions);
 147
 148         ++m_callsMade;
 149         resource->get(QueryParamsMap(), GetCallback(
 150                 std::bind(&ClientFridge::getResponse, this, "Device", PH::_1,
 151                     PH::_2, PH::_3, resource, 0)
 152                 ));
 153         ++m_callsMade;
 154         light->get(QueryParamsMap(), GetCallback(
 155                 std::bind(&ClientFridge::getResponse, this, "Fridge Light", PH::_1,
 156                     PH::_2, PH::_3, light, 1)
 157                 ));
 158         ++m_callsMade;
 159         leftdoor->get(QueryParamsMap(), GetCallback(
 160                 std::bind(&ClientFridge::getResponse, this, "Left Door", PH::_1,
 161                     PH::_2, PH::_3, leftdoor, 2)
 162                 ));
 163         ++m_callsMade;
 164         rightdoor->get(QueryParamsMap(), GetCallback(
 165                 std::bind(&ClientFridge::getResponse, this, "Right Door", PH::_1,
 166                     PH::_2, PH::_3, rightdoor, 3)
 167                 ));
 168         ++m_callsMade;
 169         randomdoor->get(QueryParamsMap(), GetCallback(
 170                 std::bind(&ClientFridge::getResponse, this, "Random Door", PH::_1,
 171                     PH::_2, PH::_3, randomdoor, 4)
 172                 ));
 173         ++m_callsMade;
 174         resource->deleteResource(DeleteCallback(
 175                 std::bind(&ClientFridge::deleteResponse, this, "Device", PH::_1,
 176                     PH::_2, resource, 0)
 177                 ));
 178     }
 179
 180     // Note that resourceName, resource, and getId are all bound via the std::bind mechanism.
 181     // it is possible to attach ANY arbitrary data to do whatever you would like here.  It may,
 182     // however be a better fit to wrap each call in an object so a fuller context (and additional
 183     // requests) can be easily made inside of a simple context
 184     void getResponse(const std::string& resourceName, const HeaderOptions& headerOptions,
 185                 const OCRepresentation& rep, const int eCode, OCResource::Ptr resource, int getId)
 186     {
 187         std::cout << "Got a response from get from the " << resourceName << std::endl;
 188         std::cout << "Get ID is "<<getId<<" and resource URI is " << resource->uri() << std::endl;
 189         std::cout << "Get eCode is "<< eCode << std::endl;
 190
 191         printHeaderOptions(headerOptions);
 192
 193         std::cout << "The Attribute Data is: "<<std::endl;
 194
 195         switch(getId)
 196         {
 197             case 0:
 198                 {
 199                     // Get on device
 200                     std::string name;
 201                     rep.getValue("device_name", name);
 202                     std::cout << "Name of device: "<< name << std::endl;
 203                     break;
 204                 }
 205             case 1:
 206                 {
 207                     bool isOn = false;
 208                     rep.getValue("on",isOn);
 209                     std::cout<<"The fridge light is "<< ((isOn)?"":"not ") <<"on"<<std::endl;
 210                 }
 211                 break;
 212             case 2:
 213             case 3:
 214                 {
 215                     bool isOpen = false;
 216                     std::string side;
 217                     rep.getValue("open", isOpen);
 218                     rep.getValue("side", side);
 219                     std::cout << "Door is "<<isOpen<<" and is on the "<<side<<std::endl;
 220                 }
 221                 break;
 222             case 4:
 223                 {
 224                     // Get on random resource called.
 225                     std::string name;
 226                     rep.getValue("device_name", name);
 227                     std::cout << "Name of fridge: "<< name << std::endl;
 228                     break;
 229                 }
 230         }
 231         ++m_callbackCount;
 232
 233         if(m_callbackCount == m_callsMade)
 234         {
 235             m_cv.notify_all();
 236         }
 237     }
 238
 239     //Callback function to handle response for deleteResource call.
 240     void deleteResponse(const std::string& resourceName, const HeaderOptions& headerOptions,
 241                 const int /*eCode*/, OCResource::Ptr resource, int deleteId)
 242     {
 243         std::cout << "Got a response from delete from the "<< resourceName << std::endl;
 244         std::cout << "Delete ID is "<<deleteId<<" and resource URI is "<<resource->uri()<<std::endl;
 245         printHeaderOptions(headerOptions);
 246
 247         ++m_callbackCount;
 248
 249         if(m_callbackCount == m_callsMade)
 250         {
 251             m_cv.notify_all();
 252         }
 253     }
 254
 255     //Function to print the headerOptions received from the server
 256     void printHeaderOptions(const HeaderOptions& headerOptions)
 257     {
 258         for (auto it = headerOptions.begin(); it != headerOptions.end(); ++it)
 259         {
 260             if(it->getOptionID() == API_VERSION)
 261             {
 262                 std::cout << "Server API version in GET response: " <<
 263                         it->getOptionData() << std::endl;
 264             }
 265         }
 266     }
 267
 268     std::mutex m_mutex;
 269     std::condition_variable m_cv;
 270     std::atomic<int> m_callbackCount;
 271     std::atomic<int> m_callsMade;
 272     OCConnectivityType m_connectivityType;
 273 };
 274
 275 int main(int argc, char* argv[])
 276 {
 277     OCConnectivityType connectivityType = CT_ADAPTER_IP;
 278     if(argc == 2)
 279     {
 280         try
 281         {
 282             std::size_t inputValLen;
 283             int optionSelected = std::stoi(argv[1], &inputValLen);
 284
 285             if(inputValLen == strlen(argv[1]))
 286             {
 287                 if(optionSelected == 0)
 288                 {
 289                     std::cout << "Using IP."<< std::endl;
 290                     connectivityType = CT_ADAPTER_IP;
 291                 }
 292                 else
 293                 {
 294                     std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
 295                     printUsage();
 296                 }
 297             }
 298             else
 299             {
 300                 std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
 301             }
 302         }
 303         catch(std::exception&)
 304         {
 305             std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
 306         }
 307     }
 308     else
 309     {
 310         printUsage();
 311         std::cout << "Default input argument. Using IP as connectivity type" << std::endl;
 312     }
 313
 314     PlatformConfig cfg
 315     {
 316         ServiceType::InProc,
 317         ModeType::Client,
 318         "0.0.0.0",
 319         0,
 320         QualityOfService::LowQos
 321     };
 322
 323     OCPlatform::Configure(cfg);
 324     ClientFridge cf(connectivityType);
 325     return 0;
 326 }
 327