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