service/notification/unittest/NSProviderSimulator.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 _NS_PROVIDER_SIMULATOR_H_
  22 #define _NS_PROVIDER_SIMULATOR_H_
  23
  24 #include <iostream>
  25
  26 #include "OCPlatform.h"
  27 #include "OCApi.h"
  28 #include "OCResourceResponse.h"
  29
  30 namespace
  31 {
  32     enum class requestType
  33     {
  34         NS_NOTIFICATION,
  35         NS_MESSAGE,
  36         NS_SYNC,
  37     };
  38 }
  39
  40 class NSProviderSimulator
  41 {
  42 private:
  43     OCResourceHandle m_notificationHandle;
  44     OCResourceHandle m_messageHandle;
  45     OCResourceHandle m_syncHandle;
  46     OC::OCRepresentation m_syncRep;
  47     OC::OCRepresentation m_messageRep;
  48     int m_accepter;
  49
  50     std::string m_notificationUri;
  51     std::string m_messageUri;
  52     std::string m_syncUri;
  53
  54     OC::ObservationIds m_syncObservers;
  55
  56 public:
  57     NSProviderSimulator()
  58     : m_notificationHandle(), m_messageHandle(), m_syncHandle(),
  59       m_syncRep(), m_messageRep(), m_accepter(0),
  60       m_notificationUri(std::string("/notification")),
  61       m_messageUri(std::string("/message")),
  62       m_syncUri(std::string("/sync")),
  63       m_syncObservers()
  64     {
  65
  66     };
  67
  68     ~NSProviderSimulator() = default;
  69
  70     NSProviderSimulator(const NSProviderSimulator &) = delete;
  71     NSProviderSimulator & operator = (const NSProviderSimulator &) = delete;
  72
  73     NSProviderSimulator(NSProviderSimulator &&) = delete;
  74     NSProviderSimulator & operator = (NSProviderSimulator &&) = delete;
  75
  76 private:
  77     std::shared_ptr<OC::OCResourceResponse> getResponse(
  78             std::shared_ptr< OC::OCResourceRequest > requests, requestType type)
  79     {
  80         auto response = std::make_shared<OC::OCResourceResponse>();
  81         response->setRequestHandle(requests->getRequestHandle());
  82         response->setResourceHandle(requests->getResourceHandle());
  83
  84         int requestFlag = requests->getRequestHandlerFlag();
  85         if (requestFlag == OC::RequestHandlerFlag::RequestFlag)
  86         {
  87             std::string request = requests->getRequestType();
  88
  89             response->setErrorCode(200);
  90             response->setResponseResult(OC_EH_OK);
  91
  92             if (request == "GET")
  93             {
  94                 OC::OCRepresentation rep;
  95
  96                 if (type == requestType::NS_NOTIFICATION)
  97                 {
  98                     std::string msgUri = m_notificationUri + m_messageUri;
  99                     std::string syncUri = m_notificationUri + m_syncUri;
 100                     std::string providerId = "123456789012345678901234567890123456";
 101                     rep.setValue("ACCEPTER", m_accepter);
 102                     rep.setValue("MESSAGE_URI", msgUri);
 103                     rep.setValue("SYNC_URI", syncUri);
 104                     rep.setValue("PROVIDER_ID", providerId);
 105                 }
 106                 else if (type == requestType::NS_SYNC)
 107                 {
 108                     rep = m_syncRep;
 109                 }
 110                 else if (type == requestType::NS_MESSAGE)
 111                 {
 112                     rep = m_messageRep;
 113                 }
 114                 else
 115                 {
 116                     return NULL;
 117                 }
 118
 119                 response->setResourceRepresentation(rep);
 120                 return response;
 121             }
 122
 123             else if (request == "POST" && type == requestType::NS_SYNC)
 124             {
 125                 m_syncRep = requests->getResourceRepresentation();
 126
 127                 std::cout << "Receive POST at Sync" << std::endl;
 128                 std::cout << "Sync Id : " << m_syncRep.getValueToString("ID") << std::endl;
 129                 std::cout << "Sync State : " << m_syncRep.getValueToString("STATE") << std::endl;
 130
 131                 response->setResourceRepresentation(m_syncRep);
 132
 133                 OC::OCPlatform::notifyListOfObservers(m_syncHandle, m_syncObservers, response);
 134
 135                 return response;
 136             }
 137         }
 138
 139         return NULL;
 140     }
 141
 142     void setObserver(std::shared_ptr< OC::OCResourceRequest > requests, requestType type)
 143     {
 144         if (type == requestType::NS_SYNC)
 145         {
 146             OC::ObservationInfo observationInfo = requests->getObservationInfo();
 147             if (OC::ObserveAction::ObserveRegister == observationInfo.action)
 148             {
 149                 m_syncObservers.push_back(observationInfo.obsId);
 150             }
 151             else if (OC::ObserveAction::ObserveUnregister == observationInfo.action)
 152             {
 153                 m_syncObservers.erase(std::remove(
 154                         m_syncObservers.begin(), m_syncObservers.end(),
 155                         observationInfo.obsId), m_syncObservers.end());
 156             }
 157         }
 158         else if (type == requestType::NS_MESSAGE)
 159         {
 160             OC::OCRepresentation rep;
 161             std::string providerId = "123456789012345678901234567890123456";
 162             rep.setValue<int>("MESSAGE_ID", (int)1);
 163             rep.setValue("PROVIDER_ID", providerId);
 164
 165             auto response = std::make_shared<OC::OCResourceResponse>();
 166             response->setRequestHandle(requests->getRequestHandle());
 167             response->setResourceHandle(requests->getResourceHandle());
 168             response->setErrorCode(200);
 169             response->setResponseResult(OC_EH_OK);
 170             response->setResourceRepresentation(rep);
 171
 172             OC::ObservationIds ids;
 173             ids.push_back(requests->getObservationInfo().obsId);
 174
 175             OC::OCPlatform::notifyListOfObservers(m_messageHandle, ids, response);
 176         }
 177     }
 178
 179     OCEntityHandlerResult entityHandler(
 180             std::shared_ptr< OC::OCResourceRequest > request, requestType type)
 181     {
 182         if (!request)
 183         {
 184             return OC_EH_ERROR;
 185         }
 186
 187         std::cout << "Provider : Income request : " << request->getRequestHandlerFlag() << std::endl;
 188         if ((request->getRequestHandlerFlag() & OC::RequestHandlerFlag::ObserverFlag))
 189         {
 190             std::cout << "Provider : Income Observe : " << std::endl;
 191             setObserver(request, type);
 192             return OC_EH_OK;
 193         }
 194
 195         auto pResponse = getResponse(request, type);
 196         if (pResponse == nullptr)
 197         {
 198             return OC_EH_ERROR;
 199         }
 200
 201         try
 202         {
 203             OC::OCPlatform::sendResponse(pResponse);
 204         }
 205         catch (std::exception & e)
 206         {
 207             return OC_EH_ERROR;
 208         }
 209
 210         return OC_EH_OK;
 211     }
 212
 213 public:
 214
 215     void setAccepter(int accepter)
 216     {
 217         m_accepter = accepter;
 218     }
 219
 220     void notifyMessage()
 221     {
 222         std::cout << "Provider : notify~" << std::endl;
 223         OC::OCPlatform::notifyAllObservers(m_messageHandle);
 224     }
 225
 226     void notifyMessage(const uint64_t & id, const std::string & title, const std::string & content)
 227     {
 228         setMessage(id, title, content);
 229         notifyMessage();
 230     }
 231
 232     void sendRead(const uint64_t & id)
 233     {
 234         std::string providerId = "123456789012345678901234567890123456";
 235         m_syncRep.setValue<int>("MESSAGE_ID", id);
 236         m_syncRep.setValue("STATE", (int)1);
 237         m_syncRep.setValue("PROVIDER_ID", providerId);
 238         OC::OCPlatform::notifyAllObservers(m_syncHandle);
 239     }
 240     void sendDismiss(const uint64_t & id)
 241     {
 242         std::string providerId = "123456789012345678901234567890123456";
 243         m_syncRep.setValue<int>("MESSAGE_ID", id);
 244         m_syncRep.setValue("STATE", (int)2);
 245         m_syncRep.setValue("PROVIDER_ID", providerId);
 246         OC::OCPlatform::notifyAllObservers(m_syncHandle);
 247     }
 248
 249     void setMessage(const uint64_t & id, const std::string & title, const std::string & content)
 250     {
 251         std::string providerId = "123456789012345678901234567890123456";
 252         m_messageRep.setValue<int>("MESSAGE_ID", id);
 253         m_messageRep.setValue("TITLE", title);
 254         m_messageRep.setValue("CONTENTTEXT", content);
 255         m_messageRep.setValue("PROVIDER_ID", providerId);
 256     }
 257
 258     void deleteNotificationResource()
 259     {
 260         OC::OCPlatform::unregisterResource(m_notificationHandle);
 261         OC::OCPlatform::unregisterResource(m_messageHandle);
 262         OC::OCPlatform::unregisterResource(m_syncHandle);
 263     }
 264
 265     void createNotificationResource()
 266     {
 267         createNotificationResource(m_notificationUri);
 268     }
 269
 270     void createNotificationResource(const std::string & uri)
 271     {
 272         if (m_notificationUri != uri)
 273         {
 274             m_notificationUri = uri;
 275         }
 276
 277         OC::OCPlatform::startPresence(30);
 278
 279         std::string notificationUri = m_notificationUri;
 280         std::string resourceTypeName = "oic.r.message.notification";
 281         std::string resourceInterface = OC::DEFAULT_INTERFACE;
 282
 283         uint8_t resourceProperty = OC_OBSERVABLE;
 284         std::string childUri = uri + m_messageUri;
 285         try
 286         {
 287             OC::OCPlatform::registerResource(
 288                     m_messageHandle, childUri,
 289                     resourceTypeName, resourceInterface,
 290                     std::bind(& NSProviderSimulator::entityHandler, this,
 291                             std::placeholders::_1, requestType::NS_MESSAGE),
 292                             resourceProperty);
 293         }
 294         catch (std::exception & e)
 295         {
 296             std::cout << e.what() << std::endl;
 297         }
 298
 299         resourceTypeName = "oic.r.sync.notification";
 300         childUri = uri + m_syncUri;
 301         try
 302         {
 303             OC::OCPlatform::registerResource(
 304                     m_syncHandle, childUri,
 305                     resourceTypeName, resourceInterface,
 306                     std::bind(& NSProviderSimulator::entityHandler, this,
 307                             std::placeholders::_1, requestType::NS_SYNC),
 308                             resourceProperty);
 309         }
 310         catch (std::exception & e)
 311         {
 312             std::cout << e.what() << std::endl;
 313         }
 314
 315         resourceProperty = OC_DISCOVERABLE;
 316         resourceTypeName = "oic.r.notification";
 317         try
 318         {
 319             OC::OCPlatform::registerResource(
 320                     m_notificationHandle, notificationUri,
 321                     resourceTypeName, resourceInterface,
 322                     std::bind(& NSProviderSimulator::entityHandler, this,
 323                             std::placeholders::_1, requestType::NS_NOTIFICATION),
 324                             resourceProperty);
 325         }
 326         catch (std::exception & e)
 327         {
 328             std::cout << e.what() << std::endl;
 329         }
 330     }
 331 };
 332
 333 #endif /* _NS_PROVIDER_SIMULATOR_H_ */