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