service/easy-setup/mediator/richsdk/inc/ESRichCommon.h

   1 //******************************************************************
   2 //
   3 // Copyright 2016 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 #ifndef ES_COMMON_RICH_H_
  22 #define ES_COMMON_RICH_H_
  23
  24 #include <iostream>
  25 #include <string>
  26 #ifndef WITH_ARDUINO
  27 #include <memory>
  28 #include <vector>
  29 #endif
  30
  31 #include "OCPlatform.h"
  32 #include "ocstack.h"
  33 #include "octypes.h"
  34
  35 #include "escommon.h"
  36
  37 using namespace OC;
  38 using namespace std;
  39
  40 #ifndef WITH_ARDUINO
  41 namespace OIC
  42 {
  43     namespace Service
  44     {
  45         /**
  46          * @brief Properties of provisioning resource. It includes a provisioning status and last
  47          *        error code.
  48          */
  49         class EnrolleeStatus
  50         {
  51         public:
  52
  53             /**
  54              * Constructor
  55              */
  56             EnrolleeStatus(const OCRepresentation& rep) { m_rep = rep; }
  57
  58             EnrolleeStatus(const EnrolleeStatus& enrolleeStatus) :
  59                 m_rep(enrolleeStatus.getRepresentation())
  60             {
  61             }
  62
  63             EnrolleeStatus(const EnrolleeStatus&& enrolleeStatus) :
  64                 m_rep(std::move(enrolleeStatus.getRepresentation()))
  65             {
  66             }
  67
  68             /**
  69              * Get a provisioning status property of Enrollee.
  70              *
  71              * @return a provisioning status property of Enrollee
  72              */
  73             ProvStatus getProvStatus()
  74             {
  75                 if(m_rep.hasAttribute(OC_RSRVD_ES_PROVSTATUS))
  76                     return static_cast<ProvStatus>(
  77                                         m_rep.getValue<int>(OC_RSRVD_ES_PROVSTATUS));
  78                 return ES_STATE_INIT;
  79             }
  80
  81             /**
  82              * Get a last error code property of Enrollee.
  83              *
  84              * @return a last error code property of Enrollee.
  85              */
  86             ESErrorCode getLastErrCode()
  87             {
  88                 if(m_rep.hasAttribute(OC_RSRVD_ES_LAST_ERRORCODE))
  89                     return static_cast<ESErrorCode>(
  90                                         m_rep.getValue<int>(OC_RSRVD_ES_LAST_ERRORCODE));
  91                 return ES_ERRCODE_NO_ERROR;
  92             }
  93
  94             /**
  95              * Get OCRepresentation object
  96              *
  97              * @return OCRepresentation object
  98              */
  99             const OCRepresentation& getRepresentation() const
 100             {
 101                 return m_rep;
 102             }
 103         protected:
 104             OCRepresentation m_rep;
 105         };
 106
 107         /**
 108          * @brief Data class stored for Cloud server property provisioning
 109          */
 110         class CloudProp
 111         {
 112         public:
 113
 114             /**
 115              * Constructor
 116              */
 117             CloudProp() {};
 118
 119             /**
 120              * Constructor with OCRepresentation object. This is used for JNI communication.
 121              */
 122             CloudProp(const OCRepresentation &rep)
 123             {
 124                 m_rep = rep;
 125                 m_cloudID = "";
 126             }
 127
 128             /**
 129              * Set CloudServer resource properties to be delivered to Enrollee
 130              *
 131              * @param authCode  Auth code issued by OAuth2.0-compatible account server
 132              * @param authProvider Auth provider ID
 133              * @param ciServer Cloud interface server URL which an Enrollee is going to registered
 134              */
 135             void setCloudProp(string authCode, string authProvider, string ciServer)
 136             {
 137                 m_rep.setValue(OC_RSRVD_ES_AUTHCODE, authCode);
 138                 m_rep.setValue(OC_RSRVD_ES_AUTHPROVIDER, authProvider);
 139                 m_rep.setValue(OC_RSRVD_ES_CISERVER, ciServer);
 140             }
 141
 142             /**
 143              * Set CloudServer's UUID
 144              *
 145              * @param cloudID Cloud Interface server's UUID
 146              */
 147             void setCloudID(string cloudID)
 148             {
 149                 m_cloudID = cloudID;
 150             }
 151
 152             /**
 153              * Get an auth code to be delivered.
 154              *
 155              * @return an auth code to be delivered.
 156              */
 157             std::string getAuthCode()
 158             {
 159                 if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHCODE))
 160                     return m_rep.getValue<std::string>(OC_RSRVD_ES_AUTHCODE);
 161                 return std::string("");
 162             }
 163
 164             /**
 165              * Get an auth provider which issued an auth code
 166              *
 167              * @return an auth provider which issued an auth code
 168              */
 169             std::string getAuthProvider()
 170             {
 171                 if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHPROVIDER))
 172                     return m_rep.getValue<std::string>(OC_RSRVD_ES_AUTHPROVIDER);
 173                 return std::string("");
 174             }
 175
 176             /**
 177              * Get a CI server to be delivered
 178              *
 179              * @return a CI server to be delivered
 180              */
 181             std::string getCiServer()
 182             {
 183                 if(m_rep.hasAttribute(OC_RSRVD_ES_CISERVER))
 184                     return m_rep.getValue<std::string>(OC_RSRVD_ES_CISERVER);
 185                 return std::string("");
 186             }
 187
 188             /**
 189              * Get a CI server's Uuid to be delivered
 190              *
 191              * @return a CI server's Uuid to be delivered
 192              */
 193             std::string getCloudID() const
 194             {
 195                 return m_cloudID;
 196             }
 197
 198             /**
 199              * Get OCRepresentation object
 200              *
 201              * @return OCRepresentation object
 202              */
 203             const OCRepresentation &toOCRepresentation() const
 204             {
 205                 return m_rep;
 206             }
 207         protected:
 208             OCRepresentation m_rep;
 209             std::string m_cloudID;
 210         };
 211
 212         /**
 213          * @brief Data class stored for Device property provisioning which includes a WiFi
 214          *        and device configuration provisioning
 215          */
 216         class DeviceProp
 217         {
 218         public:
 219
 220             /**
 221              * Constructor
 222              */
 223             DeviceProp() {}
 224
 225             /**
 226              * Constructor with OCRepresentation object. This is used for JNI communication.
 227              */
 228             DeviceProp(const OCRepresentation &rep) { m_rep = rep; }
 229
 230             /**
 231              * Set WiFi resource properties to be delivered to Enrollee
 232              *
 233              * @param ssid Ssid of the Enroller
 234              * @param pwd Pwd of the Enrolle
 235              * @param authtype Auth type of the Enroller
 236              * @param enctype Encryption type of the Enroller
 237              *
 238              * @see WIFI_AUTHTYPE
 239              * @see WIFI_ENCTYPE
 240              */
 241             void setWiFiProp(string ssid, string pwd, WIFI_AUTHTYPE authtype, WIFI_ENCTYPE enctype)
 242             {
 243                 m_rep.setValue(OC_RSRVD_ES_SSID, ssid);
 244                 m_rep.setValue(OC_RSRVD_ES_CRED, pwd);
 245                 m_rep.setValue(OC_RSRVD_ES_AUTHTYPE, authtype);
 246                 m_rep.setValue(OC_RSRVD_ES_ENCTYPE, enctype);
 247             }
 248
 249             /**
 250              * Set DevConf resource properties to be delivered to Enrollee
 251              *
 252              * @param language IETF language tag using ISO 639X
 253              * @param country ISO Country Code (ISO 3166-1 Alpha-2)
 254              */
 255             void setDevConfProp(string language, string country)
 256             {
 257                 m_rep.setValue(OC_RSRVD_ES_LANGUAGE, language);
 258                 m_rep.setValue(OC_RSRVD_ES_COUNTRY, country);
 259             }
 260
 261             /**
 262              * Get a SSID of Enroller
 263              *
 264              * @return a SSID of enroller
 265              */
 266             std::string getSsid()
 267             {
 268                 if(m_rep.hasAttribute(OC_RSRVD_ES_SSID))
 269                     return m_rep.getValue<std::string>(OC_RSRVD_ES_SSID);
 270                 return std::string("");
 271             }
 272
 273             /**
 274              * Get a password of Enroller
 275              *
 276              * @return a password of enroller
 277              */
 278             std::string getPassword()
 279             {
 280                 if(m_rep.hasAttribute(OC_RSRVD_ES_CRED))
 281                     return m_rep.getValue<std::string>(OC_RSRVD_ES_CRED);
 282                 return std::string("");
 283             }
 284
 285             /**
 286              * Get an auth type of Enroller
 287              *
 288              * @return an auth type of enroller
 289              *
 290              * @see WIFI_AUTHTYPE
 291              */
 292             WIFI_AUTHTYPE getAuthType()
 293             {
 294                 if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHTYPE))
 295                     return static_cast<WIFI_AUTHTYPE>(m_rep.getValue<int>(OC_RSRVD_ES_AUTHTYPE));
 296                 return NONE_AUTH;
 297             }
 298
 299             /**
 300              * Get an encryption type of Enroller
 301              *
 302              * @return an encryption type of enroller
 303              *
 304              * @see WIFI_ENCTYPE
 305              */
 306             WIFI_ENCTYPE getEncType()
 307             {
 308                 if(m_rep.hasAttribute(OC_RSRVD_ES_ENCTYPE))
 309                     return static_cast<WIFI_ENCTYPE>(m_rep.getValue<int>(OC_RSRVD_ES_ENCTYPE));
 310                 return NONE_ENC;
 311             }
 312
 313             /**
 314              * Get a language to be set. A language is expressed in IETF language tag
 315              * using ISO 639X.
 316              *
 317              * @return a language to be set
 318              */
 319             std::string getLanguage()
 320             {
 321                 if(m_rep.hasAttribute(OC_RSRVD_ES_LANGUAGE))
 322                     return m_rep.getValue<std::string>(OC_RSRVD_ES_LANGUAGE);
 323                 return std::string("");
 324             }
 325
 326             /**
 327              * Get a country to be set. A country is expressed in ISO Country Code
 328              * (ISO 3166-1 Alpha-2)
 329              *
 330              * @return a country to be set
 331              */
 332             std::string getCountry()
 333             {
 334                 if(m_rep.hasAttribute(OC_RSRVD_ES_COUNTRY))
 335                     return m_rep.getValue<std::string>(OC_RSRVD_ES_COUNTRY);
 336                 return std::string("");
 337             }
 338
 339             /**
 340              * Get OCRepresentation object
 341              *
 342              * @return OCRepresentation object
 343              */
 344             const OCRepresentation &toOCRepresentation() const
 345             {
 346                 return m_rep;
 347             }
 348
 349         protected:
 350             OCRepresentation m_rep;
 351         };
 352
 353         /**
 354          * @brief Provisioning state in cloud server property provisioning.
 355          */
 356         typedef enum
 357         {
 358             ES_CLOUD_PROVISIONING_ERROR = -1,   /**< An error in cloud provisioning happens **/
 359             ES_CLOUD_PROVISIONING_SUCCESS,      /**< Cloud provisioning is successfully done **/
 360             ES_CLOUD_ENROLLEE_FOUND,            /**< An enrollee is found in a given network **/
 361             ES_CLOUD_ENROLLEE_NOT_FOUND         /**< NO enrollee is found in a given network **/
 362         }ESCloudProvState;
 363
 364         /**
 365          * Security Provisioning Status
 366          */
 367         class SecProvisioningStatus
 368         {
 369         public:
 370             SecProvisioningStatus(string deviceUUID, ESResult result) :
 371                 m_devUUID(deviceUUID), m_result(result)
 372             {
 373             }
 374
 375             const string getDeviceUUID()
 376             {
 377                 return m_devUUID;
 378             }
 379
 380             ESResult getESResult()
 381             {
 382                 return m_result;
 383             }
 384         private:
 385             string m_devUUID;
 386             ESResult m_result;
 387         };
 388
 389         /**
 390          * @breif This provide a set of getter APIs from received response for getConfiguration().
 391          *        Received information includes a device name, WiFi supported mode, and frequency.
 392          *        Additionally, you can know if Enrollee can be access to cloud server with this
 393          *        object.
 394          */
 395         class EnrolleeConf
 396         {
 397         public:
 398             /**
 399              * Constructor
 400              * The expected OCRepresentation is one for collection resource and has several child
 401              * OCRepresentation object corresponding to WiFi, DevConf, and CloudServer resource's
 402              * representation.
 403              */
 404             EnrolleeConf(const OCRepresentation& rep)
 405             {
 406                 m_ProvRep = rep;
 407
 408                 std::vector<OCRepresentation> children = rep.getChildren();
 409
 410                 for(auto child = children.begin(); child != children.end(); ++child)
 411                 {
 412                     if(child->getUri().find(OC_RSRVD_ES_URI_WIFI) != std::string::npos)
 413                     {
 414                         m_WiFiRep = *child;
 415                     }
 416                     else if(child->getUri().find(OC_RSRVD_ES_URI_DEVCONF) != std::string::npos)
 417                     {
 418                         m_DevConfRep = *child;
 419                     }
 420                     else if(child->getUri().find(OC_RSRVD_ES_URI_CLOUDSERVER) != std::string::npos)
 421                     {
 422                         m_CloudRep = *child;
 423                     }
 424                 }
 425             }
 426
 427             /**
 428              * Get a device name of Enrollee. It is Device's human-friendly name like device model
 429              * name.
 430              *
 431              * @return a device name of Enrollee
 432              */
 433             std::string getDeviceName()
 434             {
 435                 if(m_DevConfRep.hasAttribute(OC_RSRVD_ES_DEVNAME))
 436                     return m_DevConfRep.getValue<std::string>(OC_RSRVD_ES_DEVNAME);
 437                 return std::string("");
 438             }
 439
 440             /**
 441              * Get a set of WiFi supported modes of Enrollee
 442              *
 443              * @return a set of WiFi supported modes of Enrollee
 444              *
 445              * @see WIFI_MODE
 446              */
 447             vector<WIFI_MODE> getWiFiModes()
 448             {
 449                 vector<WIFI_MODE> modes;
 450                 modes.clear();
 451
 452                 if(m_WiFiRep.hasAttribute(OC_RSRVD_ES_SUPPORTEDWIFIMODE))
 453                 {
 454                     for(auto it : m_WiFiRep.getValue
 455                                         <std::vector<int>>(OC_RSRVD_ES_SUPPORTEDWIFIMODE))
 456                     {
 457                         modes.push_back(static_cast<WIFI_MODE>(it));
 458                     }
 459                 }
 460                 return modes;
 461             }
 462
 463             /**
 464              * Get a WiFi supported frequency of Enrollee
 465              *
 466              * @return a WiFi supported frequency of Enrollee
 467              *
 468              * @see WIFI_FREQ
 469              */
 470             WIFI_FREQ getWiFiFreq()
 471             {
 472                 if(m_WiFiRep.hasAttribute(OC_RSRVD_ES_SUPPORTEDWIFIFREQ))
 473                     return static_cast<WIFI_FREQ>(
 474                                         m_WiFiRep.getValue<int>(OC_RSRVD_ES_SUPPORTEDWIFIFREQ));
 475                 return WIFI_FREQ_NONE;
 476             }
 477
 478             /**
 479              * Get an accessibility to cloud server of an Enrollee
 480              *
 481              * @return an accessibility to cloud server of an Enrollee
 482              */
 483             bool isCloudAccessible()
 484             {
 485                 if(m_CloudRep.getUri().find(OC_RSRVD_ES_URI_CLOUDSERVER) != std::string::npos)
 486                 {
 487                     return true;
 488                 }
 489                 return false;
 490             }
 491
 492             /**
 493              * Get OCRepresentation object
 494              *
 495              * @return OCRepresentation object
 496              */
 497             const OCRepresentation& getProvResRep()
 498             {
 499                 return m_ProvRep;
 500             }
 501
 502         protected:
 503             OCRepresentation m_ProvRep, m_WiFiRep, m_DevConfRep, m_CloudRep;
 504         };
 505
 506         /**
 507          * Status object for getStatus API. This object is given to application
 508          * when a response for GET request to provisioning resource at Enrollee is arrived.
 509          * It returns a result of the API and requested data delivered in the response which includes
 510          * a provisioning status and last error code stored in Enrollee.
 511          *
 512          * @see EnrolleeStatus
 513          */
 514         class GetEnrolleeStatus
 515         {
 516         public:
 517             GetEnrolleeStatus(ESResult result, const EnrolleeStatus& status) :
 518                 m_result(result), m_enrolleeStatus(status)
 519             {
 520             }
 521
 522             ESResult getESResult()
 523             {
 524                 return m_result;
 525             }
 526
 527             const EnrolleeStatus& getEnrolleeStatus()
 528             {
 529                 return m_enrolleeStatus;
 530             }
 531
 532         private:
 533             ESResult m_result;
 534             EnrolleeStatus m_enrolleeStatus;
 535         };
 536
 537         /**
 538          * Status object for getConfiguration API. This object is given to application
 539          * when a response for GET request to provisioning resource at Enrollee is arrived.
 540          * It returns a result of the API and requested data delivered in the response which includes
 541          * WiFi configuration and device configuration stored in Enrollee.
 542          *
 543          * @see EnrolleeConf
 544          */
 545         class GetConfigurationStatus
 546         {
 547         public:
 548             GetConfigurationStatus(ESResult result, const EnrolleeConf& conf) :
 549                     m_result(result), m_enrolleeConf(conf)
 550             {
 551             }
 552
 553             ESResult getESResult()
 554             {
 555                 return m_result;
 556             }
 557
 558             const EnrolleeConf& getEnrolleeConf()
 559             {
 560                 return m_enrolleeConf;
 561             }
 562
 563         private:
 564             ESResult m_result;
 565             EnrolleeConf m_enrolleeConf;
 566         };
 567
 568         /**
 569          * Status object for provisionDeviceProperties API. This object is given to application
 570          * when a response for GET request to provisioning resource at Enrollee is arrived.
 571          * It returns a result of the request.
 572          */
 573         class DevicePropProvisioningStatus
 574         {
 575         public:
 576             DevicePropProvisioningStatus(ESResult result) :
 577                     m_result(result)
 578             {
 579             }
 580
 581             ESResult getESResult()
 582             {
 583                 return m_result;
 584             }
 585
 586
 587         private:
 588             ESResult m_result;
 589         };
 590
 591         /**
 592          * Status object for provisionCloudProperties API. This object is given to application
 593          * when a response for GET request to provisioning resource at Enrollee is arrived.
 594          * It returns a result of the request and status of this provisioning. The status provides
 595          * an information if the enrollee is found in a given network and the provisioning is
 596          * successfully done.
 597          */
 598         class CloudPropProvisioningStatus
 599         {
 600         public:
 601             CloudPropProvisioningStatus(ESResult result, ESCloudProvState state) :
 602                     m_result(result), m_esCloudState(state)
 603             {
 604             }
 605
 606             ESResult getESResult()
 607             {
 608                 return m_result;
 609             }
 610
 611             ESCloudProvState getESCloudState()
 612             {
 613                 return m_esCloudState;
 614             }
 615
 616         private:
 617             ESResult m_result;
 618             ESCloudProvState m_esCloudState;
 619         };
 620
 621         /**
 622          * Callback function definition for providing Enrollee status
 623          */
 624         typedef function< void(shared_ptr< GetEnrolleeStatus >) > GetStatusCb;
 625
 626         /**
 627          * Callback function definition for providing Enrollee configuration status
 628          */
 629         typedef function< void(shared_ptr< GetConfigurationStatus >) > GetConfigurationStatusCb;
 630
 631         /**
 632          * Callback function definition for providing Enrollee device property provisioning status
 633          */
 634         typedef function< void(shared_ptr< DevicePropProvisioningStatus >) > DevicePropProvStatusCb;
 635
 636         /**
 637          * Callback function definition for providing Enrollee cloud property provisioning status
 638          */
 639         typedef function< void(shared_ptr< CloudPropProvisioningStatus >) > CloudPropProvStatusCb;
 640
 641         /**
 642          * Callback function definition for providing Enrollee security provisioning status
 643          */
 644         typedef function< void(shared_ptr<SecProvisioningStatus>) > SecurityProvStatusCb;
 645
 646         /**
 647          * Callback definition to be invoked when the security stack expects a pin from application
 648          */
 649         typedef function< void(string&) > SecurityPinCb;
 650
 651         /**
 652          * Callback definition to be invoked when the stack expects a db path
 653          */
 654         typedef function< void(string&) > SecProvisioningDbPathCb;
 655
 656     }
 657 }
 658 #endif //WITH_ARDUINO
 659
 660 #endif //ES_COMMON_RICH_H_