resource/include/InProcClientWrapper.h

   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 #ifndef OC_IN_PROC_CLIENT_WRAPPER_H_
  22 #define OC_IN_PROC_CLIENT_WRAPPER_H_
  23
  24 #include <thread>
  25 #include <mutex>
  26 #include <sstream>
  27 #include <iostream>
  28
  29 #include <OCApi.h>
  30 #include <IClientWrapper.h>
  31 #include <InitializeException.h>
  32 #include <ResourceInitException.h>
  33 #ifdef WITH_PROCESS_EVENT
  34 #include "ocevent.h"
  35 #endif
  36
  37 namespace OC
  38 {
  39     namespace ClientCallbackContext
  40     {
  41         struct GetContext
  42         {
  43             GetCallback callback;
  44             GetContext(GetCallback cb) : callback(cb){}
  45         };
  46
  47         struct SetContext
  48         {
  49             PutCallback callback;
  50             SetContext(PutCallback cb) : callback(cb){}
  51         };
  52
  53         struct ListenContext
  54         {
  55             FindCallback callback;
  56             std::weak_ptr<IClientWrapper> clientWrapper;
  57
  58             ListenContext(FindCallback cb, std::weak_ptr<IClientWrapper> cw)
  59                 : callback(cb), clientWrapper(cw){}
  60         };
  61
  62         struct ListenErrorContext
  63         {
  64             FindCallback callback;
  65             FindErrorCallback errorCallback;
  66             std::weak_ptr<IClientWrapper> clientWrapper;
  67
  68             ListenErrorContext(FindCallback cb1, FindErrorCallback cb2,
  69                                std::weak_ptr<IClientWrapper> cw)
  70                 : callback(cb1), errorCallback(cb2), clientWrapper(cw){}
  71         };
  72
  73         struct ListenResListContext
  74         {
  75             FindResListCallback callback;
  76             std::weak_ptr<IClientWrapper> clientWrapper;
  77
  78             ListenResListContext(FindResListCallback cb, std::weak_ptr<IClientWrapper> cw)
  79                 : callback(cb), clientWrapper(cw){}
  80         };
  81
  82         struct ListenResListWithErrorContext
  83         {
  84             FindResListCallback callback;
  85             FindErrorCallback errorCallback;
  86             std::weak_ptr<IClientWrapper> clientWrapper;
  87
  88             ListenResListWithErrorContext(FindResListCallback cb1, FindErrorCallback cb2,
  89                                std::weak_ptr<IClientWrapper> cw)
  90                 : callback(cb1), errorCallback(cb2), clientWrapper(cw){}
  91         };
  92
  93         struct DeviceListenContext
  94         {
  95             FindDeviceCallback callback;
  96             IClientWrapper::Ptr clientWrapper;
  97             DeviceListenContext(FindDeviceCallback cb, IClientWrapper::Ptr cw)
  98                     : callback(cb), clientWrapper(cw){}
  99         };
 100
 101         struct SubscribePresenceContext
 102         {
 103             SubscribeCallback callback;
 104             SubscribePresenceContext(SubscribeCallback cb) : callback(cb){}
 105         };
 106
 107         struct DeleteContext
 108         {
 109             DeleteCallback callback;
 110             DeleteContext(DeleteCallback cb) : callback(cb){}
 111         };
 112
 113         struct ObserveContext
 114         {
 115             ObserveCallback callback;
 116             ObserveContext(ObserveCallback cb) : callback(cb){}
 117         };
 118
 119         struct DirectPairingContext
 120         {
 121             DirectPairingCallback callback;
 122             DirectPairingContext(DirectPairingCallback cb) : callback(cb){}
 123
 124         };
 125 #ifdef TCP_ADAPTER
 126         struct KeepAliveContext
 127         {
 128             KeepAliveCallback callback;
 129             KeepAliveContext(KeepAliveCallback cb) : callback(cb){}
 130         };
 131 #endif
 132
 133 #ifdef WITH_MQ
 134         struct MQTopicContext
 135         {
 136             MQTopicCallback callback;
 137             std::weak_ptr<IClientWrapper> clientWrapper;
 138             MQTopicContext(MQTopicCallback cb, std::weak_ptr<IClientWrapper> cw)
 139                 : callback(cb), clientWrapper(cw){}
 140         };
 141 #endif
 142     }
 143
 144     class InProcClientWrapper : public IClientWrapper
 145     {
 146
 147     public:
 148
 149         InProcClientWrapper(std::weak_ptr<std::recursive_mutex> csdkLock,
 150                             PlatformConfig cfg);
 151         virtual ~InProcClientWrapper();
 152
 153         virtual OCStackResult ListenForResource(const std::string& serviceUrl,
 154             const std::string& resourceType, OCConnectivityType transportFlags,
 155             FindCallback& callback, QualityOfService QoS);
 156
 157         virtual OCStackResult ListenForResourceList(const std::string& serviceUrl,
 158             const std::string& resourceType, OCConnectivityType transportFlags,
 159             FindResListCallback& callback, QualityOfService QoS);
 160
 161         virtual OCStackResult ListenForResourceListWithError(const std::string& serviceUrl,
 162             const std::string& resourceType, OCConnectivityType connectivityType,
 163             FindResListCallback& callback, FindErrorCallback& errorCallback,
 164             QualityOfService QoS);
 165
 166         virtual OCStackResult ListenErrorForResource(const std::string& serviceUrl,
 167             const std::string& resourceType, OCConnectivityType transportFlags,
 168             FindCallback& callback, FindErrorCallback& errorCallback, QualityOfService QoS);
 169
 170         virtual OCStackResult ListenForDevice(const std::string& serviceUrl,
 171             const std::string& deviceURI, OCConnectivityType transportFlags,
 172             FindDeviceCallback& callback, QualityOfService QoS);
 173
 174         virtual OCStackResult GetResourceRepresentation(
 175             const OCDevAddr& devAddr,
 176             const std::string& uri,
 177             const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
 178             OCConnectivityType connectivityType,
 179             GetCallback& callback, QualityOfService QoS);
 180
 181         virtual OCStackResult PutResourceRepresentation(
 182             const OCDevAddr& devAddr,
 183             const std::string& uri,
 184             const OCRepresentation& attributes, const QueryParamsMap& queryParams,
 185             const HeaderOptions& headerOptions, PutCallback& callback, QualityOfService QoS);
 186
 187         virtual OCStackResult PostResourceRepresentation(
 188             const OCDevAddr& devAddr,
 189             const std::string& uri,
 190             const OCRepresentation& attributes, const QueryParamsMap& queryParams,
 191             const HeaderOptions& headerOptions, OCConnectivityType connectivityType,
 192             PostCallback& callback, QualityOfService QoS);
 193
 194         virtual OCStackResult DeleteResource(
 195             const OCDevAddr& devAddr,
 196             const std::string& uri,
 197             const HeaderOptions& headerOptions,
 198             OCConnectivityType connectivityType,
 199             DeleteCallback& callback, QualityOfService QoS);
 200
 201         virtual OCStackResult ObserveResource(
 202             ObserveType observeType, OCDoHandle* handle,
 203             const OCDevAddr& devAddr,
 204             const std::string& uri,
 205             const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
 206             ObserveCallback& callback, QualityOfService QoS);
 207
 208         virtual OCStackResult CancelObserveResource(
 209             OCDoHandle handle,
 210             const std::string& host,
 211             const std::string& uri,
 212             const HeaderOptions& headerOptions, QualityOfService QoS);
 213
 214         virtual OCStackResult SubscribePresence(
 215             OCDoHandle *handle,
 216             const std::string& host,
 217             const std::string& resourceType,
 218             OCConnectivityType transportFlags,
 219             SubscribeCallback& presenceHandler);
 220
 221         virtual OCStackResult UnsubscribePresence(OCDoHandle handle);
 222
 223 #ifdef WITH_CLOUD
 224         virtual OCStackResult SubscribeDevicePresence(OCDoHandle* handle,
 225                                                       const std::string& host,
 226                                                       const std::vector<std::string>& di,
 227                                                       OCConnectivityType connectivityType,
 228                                                       ObserveCallback& callback);
 229 #endif
 230
 231         OCStackResult GetDefaultQos(QualityOfService& QoS);
 232
 233         virtual OCStackResult FindDirectPairingDevices(unsigned short waittime,
 234                        GetDirectPairedCallback& callback);
 235
 236         virtual OCStackResult GetDirectPairedDevices(GetDirectPairedCallback& callback);
 237
 238         virtual OCStackResult DoDirectPairing(std::shared_ptr<OCDirectPairing> peer, const OCPrm_t& pmSel,
 239                 const std::string& pinNumber, DirectPairingCallback& resultCallback);
 240
 241 #ifdef WITH_MQ
 242         virtual OCStackResult ListenForMQTopic(
 243             const OCDevAddr& devAddr,
 244             const std::string& resourceUri,
 245             const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
 246             MQTopicCallback& callback, QualityOfService QoS);
 247
 248         virtual OCStackResult PutMQTopicRepresentation(
 249             const OCDevAddr& devAddr,
 250             const std::string& uri,
 251             const OCRepresentation& rep,
 252             const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
 253             MQTopicCallback& callback, QualityOfService QoS);
 254 #endif
 255
 256         virtual OCStackResult stop();
 257         virtual OCStackResult start();
 258
 259 #ifdef TCP_ADAPTER
 260         virtual OCStackResult findKeepAliveResource(std::string host,
 261                                                     KeepAliveCallback resultCallback);
 262         virtual OCStackResult sendKeepAliveRequest(std::string host, const OCRepresentation& rep,
 263                                                              KeepAliveCallback resultCallback);
 264 #endif
 265
 266     private:
 267         void listeningFunc();
 268         std::string assembleSetResourceUri(std::string uri, const QueryParamsMap& queryParams);
 269         std::string assembleSetResourceUri(std::string uri, const QueryParamsList& queryParams);
 270         OCPayload* assembleSetResourcePayload(const OCRepresentation& attributes);
 271         OCHeaderOption* assembleHeaderOptions(const HeaderOptions& headerOptions);
 272         void convert(const OCDPDev_t *list, PairedDevices& dpList);
 273         std::thread m_listeningThread;
 274         bool m_threadRun;
 275         std::weak_ptr<std::recursive_mutex> m_csdkLock;
 276
 277     private:
 278         PlatformConfig  m_cfg;
 279 #ifdef WITH_PROCESS_EVENT
 280         oc_event m_processEvent;
 281 #endif
 282     };
 283 }
 284
 285 #endif
 286