moved Broker's whole class into namespace OIC::Service.
added exception of Broker API.
changed hostResource return type to const type.
changed cancelHostResource return type to void.
aligned source and header files.
Added initializer for each class.
Change-Id: I65278e2eab1c3621240e9242bdd3f07d592f7911
Signed-off-by: jyong2.kim <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/1472
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Madan Lanka <lanka.madan@samsung.com>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
resourcebroker_env.InstallTarget(resourcebrokersdk, 'libResouceBroker')
# Go to build sample apps
-SConscript('SampleApp/SConscript')
+#SConscript('SampleApp/SConscript')
#include "logger.h"
#include "PrimitiveResource.h"
-#define BROKER_TAG PCF("BROKER")
-#define SAFE_TIME (5l)
-#define BROKER_TRANSPORT OCConnectivityType::CT_ADAPTER_IP
-
-using namespace OIC::Service;
-
-/*
- * @BROKER_STATE
- * brief : resourcePresence state
- * ALIVE - It means that 'getCB' function receives 'OK' message
- * REQUESTED - It means that broker receives the request for presence checking
- * LOST_SIGNAL - In case that 'getCB' function receives the message except 'OK'
- * DESTROYED - In case that the presence checking is dismissed for the resource ,
- * or there is no matched value in the Broker Callback list
- * NONE - To be determined.
- */
-enum class BROKER_STATE
+namespace OIC
{
- ALIVE = 0,
- REQUESTED,
- LOST_SIGNAL,
- DESTROYED,
- NONE
-};
-
-/*
- * @DEVICE_STATE
- * brief : devicePresence state
- * ALIVE - It means that 'subscribeCB' function receives 'OK' message
- * REQUESTED - It means that broker receives the request for presence checking
- * LOST_SIGNAL - In case that 'subscribeCB' function receives the message except 'OK'
- */
-enum class DEVICE_STATE
-{
- ALIVE = 0,
- REQUESTED,
- LOST_SIGNAL
-};
-
-enum class BROKER_MODE
-{
- DEVICE_PRESENCE_MODE = 0,
- NON_PRESENCE_MODE
-};
-
-typedef unsigned int BrokerID;
-
-typedef std::function<void(BROKER_STATE)> BrokerCB;
-struct BrokerRequesterInfo
-{
- BrokerID brockerId;
- BrokerCB brockerCB;
-};
-typedef std::shared_ptr<BrokerRequesterInfo> BrokerRequesterInfoPtr;
-
-class ResourcePresence;
-class DevicePresence;
-
-typedef std::function<void(std::shared_ptr<OC::OCResource>)> FindCB;
-
-typedef std::shared_ptr<PrimitiveResource> PrimitiveResourcePtr;
-
-typedef std::shared_ptr<ResourcePresence> ResourcePresencePtr;
-typedef std::shared_ptr<DevicePresence> DevicePresencePtr;
-typedef std::list< ResourcePresencePtr > PresenceList;
-
-struct BrokerCBResourcePair
-{
- BrokerCBResourcePair(ResourcePresencePtr pResource, BrokerCB cb)
- : pResource(pResource), brokerCB(cb){}
- ResourcePresencePtr pResource;
- BrokerCB brokerCB;
-};
-typedef std::map<BrokerID, BrokerCBResourcePair> BrokerIDMap;
-
-typedef std::function<void(OCStackResult, const unsigned int,
- const std::string&)> SubscribeCB;
-
-typedef std::function<void(const HeaderOptions&, const ResponseStatement&, int)> RequestGetCB;
-typedef std::function<void * (unsigned int)> TimeoutCB;
+ namespace Service
+ {
+ #define BROKER_TAG PCF("BROKER")
+ #define SAFE_TIME (5l)
+ #define BROKER_TRANSPORT OCConnectivityType::CT_ADAPTER_IP
+
+ /*
+ * @BROKER_STATE
+ * brief : resourcePresence state
+ * ALIVE - It means that 'getCB' function receives 'OK' message
+ * REQUESTED - It means that broker receives the request for presence checking
+ * LOST_SIGNAL - In case that 'getCB' function receives the message except 'OK'
+ * DESTROYED - In case that the presence checking is dismissed for the resource ,
+ * or there is no matched value in the Broker Callback list
+ * NONE - To be determined.
+ */
+ enum class BROKER_STATE
+ {
+ ALIVE = 0,
+ REQUESTED,
+ LOST_SIGNAL,
+ DESTROYED,
+ NONE
+ };
+
+ /*
+ * @DEVICE_STATE
+ * brief : devicePresence state
+ * ALIVE - It means that 'subscribeCB' function receives 'OK' message
+ * REQUESTED - It means that broker receives the request for presence checking
+ * LOST_SIGNAL - In case that 'subscribeCB' function receives the message except 'OK'
+ */
+ enum class DEVICE_STATE
+ {
+ ALIVE = 0,
+ REQUESTED,
+ LOST_SIGNAL
+ };
+
+ enum class BROKER_MODE
+ {
+ DEVICE_PRESENCE_MODE = 0,
+ NON_PRESENCE_MODE
+ };
+
+ typedef unsigned int BrokerID;
+
+ typedef std::function<void(BROKER_STATE)> BrokerCB;
+ struct BrokerRequesterInfo
+ {
+ BrokerID brockerId;
+ BrokerCB brockerCB;
+ };
+ typedef std::shared_ptr<BrokerRequesterInfo> BrokerRequesterInfoPtr;
+
+ class ResourcePresence;
+ class DevicePresence;
+
+ typedef std::function<void(std::shared_ptr<OC::OCResource>)> FindCB;
+
+ typedef std::shared_ptr<PrimitiveResource> PrimitiveResourcePtr;
+
+ typedef std::shared_ptr<ResourcePresence> ResourcePresencePtr;
+ typedef std::shared_ptr<DevicePresence> DevicePresencePtr;
+ typedef std::list< ResourcePresencePtr > PresenceList;
+
+ struct BrokerCBResourcePair
+ {
+ BrokerCBResourcePair(ResourcePresencePtr pResource, BrokerCB cb)
+ : pResource(pResource), brokerCB(cb){}
+ ResourcePresencePtr pResource;
+ BrokerCB brokerCB;
+ };
+ typedef std::map<BrokerID, BrokerCBResourcePair> BrokerIDMap;
+
+ typedef std::function<void(OCStackResult, const unsigned int,
+ const std::string&)> SubscribeCB;
+
+ typedef std::function<void(const HeaderOptions&, const ResponseStatement&, int)> RequestGetCB;
+ typedef std::function<void * (unsigned int)> TimeoutCB;
+ } // namespace Service
+} // namespace OIC
#endif // BROKERTYPES_H_
#include "BrokerTypes.h"
-class DeviceAssociation {
-public:
- static DeviceAssociation * getInstance();
-
- DevicePresencePtr findDevice(const std::string & address);
- void addDevice(DevicePresencePtr dPresence);
- void removeDevice(DevicePresencePtr dPresence);
-
-private:
- DeviceAssociation();
- ~DeviceAssociation();
-
- static DeviceAssociation * s_instance;
- static std::mutex s_mutexForCreation;
- static std::list< DevicePresencePtr > s_deviceList;
-};
+namespace OIC
+{
+ namespace Service
+ {
+ class DeviceAssociation {
+ public:
+
+ static DeviceAssociation * getInstance();
+
+ DevicePresencePtr findDevice(const std::string & address);
+ void addDevice(DevicePresencePtr dPresence);
+ void removeDevice(DevicePresencePtr dPresence);
+
+ private:
+ DeviceAssociation();
+ ~DeviceAssociation();
+
+ static DeviceAssociation * s_instance;
+ static std::mutex s_mutexForCreation;
+ static std::list< DevicePresencePtr > s_deviceList;
+ };
+ } // namespace Service
+} // namespace OIC
#endif /* DEVICEASSOCIATION_H_ */
#include "ResourcePresence.h"
#include "PresenceSubscriber.h"
-class DevicePresence
+namespace OIC
{
-public:
- DevicePresence(PrimitiveResourcePtr pResource);
- ~DevicePresence();
+ namespace Service
+ {
+ class DevicePresence
+ {
+ public:
+ DevicePresence();
+ ~DevicePresence();
- void addPresenceResource(ResourcePresence * rPresence);
- void removePresenceResource(ResourcePresence * rPresence);
+ void initializeDevicePresence(PrimitiveResourcePtr pResource);
- bool isEmptyResourcePresence() const;
- const std::string getAddress() const;
+ void addPresenceResource(ResourcePresence * rPresence);
+ void removePresenceResource(ResourcePresence * rPresence);
-private:
- void requestAllResourcePresence();
- void subscribeCB(OCStackResult ret,const unsigned int seq, const std::string& Hostaddress);
- void * timeOutCB(unsigned int msg);
+ bool isEmptyResourcePresence() const;
+ const std::string getAddress() const;
- std::list<ResourcePresence * > resourcePresenceList;
+ private:
+ void requestAllResourcePresence();
+ void subscribeCB(OCStackResult ret,const unsigned int seq, const std::string& Hostaddress);
+ void * timeOutCB(unsigned int msg);
- std::string address;
- DEVICE_STATE state;
- bool isWithinTime;
+ std::list<ResourcePresence * > resourcePresenceList;
- SubscribeCB pSubscribeRequestCB;
- TimeoutCB pTimeoutCB;
- PresenceSubscriber presenceSubscriber;
+ std::string address;
+ DEVICE_STATE state;
+ bool isWithinTime;
-
-
-};
+ SubscribeCB pSubscribeRequestCB;
+ TimeoutCB pTimeoutCB;
+ PresenceSubscriber presenceSubscriber;
+ };
+ } // namespace Service
+} // namespace OIC
#endif /* DEVICEPRESENCE_H_ */
#include "BrokerTypes.h"
#include "ResourcePresence.h"
-class ResourceBroker
+namespace OIC
{
-public:
- static ResourceBroker * getInstance();
+ namespace Service
+ {
+ class ResourceBroker
+ {
+ public:
+ class InvalidParameter: public PrimitiveException
+ {
+ public:
+ InvalidParameter(std::string&& what) : PrimitiveException{ std::move(what) } {}
+ };
- BrokerID hostResource(PrimitiveResourcePtr pResource, BrokerCB cb);
- BrokerID cancelHostResource(BrokerID brokerId);
+ static ResourceBroker * getInstance();
- BROKER_STATE getResourceState(BrokerID brokerId);
- BROKER_STATE getResourceState(PrimitiveResourcePtr pResource);
+ const BrokerID hostResource(PrimitiveResourcePtr pResource, BrokerCB cb);
+ void cancelHostResource(BrokerID brokerId);
-private:
- ResourceBroker();
- ~ResourceBroker();
+ BROKER_STATE getResourceState(BrokerID brokerId);
+ BROKER_STATE getResourceState(PrimitiveResourcePtr pResource);
- BrokerID generateBrokerID();
- ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource);
+ private:
+ static ResourceBroker * s_instance;
+ static std::mutex s_mutexForCreation;
+ static std::unique_ptr<PresenceList> s_presenceList;
+ static std::unique_ptr<BrokerIDMap> s_brokerIDMap;
- static ResourceBroker * s_instance;
- static std::mutex s_mutexForCreation;
- static std::unique_ptr<PresenceList> s_presenceList;
- static std::unique_ptr<BrokerIDMap> s_brokerIDMap;
-};
+ ResourceBroker() = default;
+ ~ResourceBroker();
+ ResourceBroker(const ResourceBroker&) = delete;
+ ResourceBroker(ResourceBroker&&) = delete;
+
+ ResourceBroker& operator=(const ResourceBroker&) const = delete;
+ ResourceBroker& operator=(ResourceBroker&&) const = delete;
+
+ void initializeResourceBroker();
+ BrokerID generateBrokerID();
+ ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource);
+ };
+ } // namespace Service
+} // namespace OIC
#endif /* RESOURCEBROKER_H_ */
#include <list>
#include <string>
#include <atomic>
+#include <mutex>
+#include <condition_variable>
#include "BrokerTypes.h"
-#include "../../common/primitiveTimer/include/PrimitiveTimer.h"
+#include "PrimitiveTimer.h"
-class ResourcePresence
+namespace OIC
{
-public:
- ResourcePresence(PrimitiveResourcePtr pResource);
- ~ResourcePresence();
-
- void addBrokerRequester(BrokerID _id, BrokerCB _cb);
- void removeBrokerRequester(BrokerID _id);
- void removeAllBrokerRequester();
- void requestResourceState();
- void setResourcestate(BROKER_STATE _state);
- void executeAllBrokerCB(BROKER_STATE changedState);
- void changePresenceMode(BROKER_MODE newMode);
-
- bool isEmptyRequester() const;
-
- PrimitiveResourcePtr getPrimitiveResource();
- BROKER_STATE getResourceState();
-
-private:
- void getCB(const HeaderOptions &hos, const ResponseStatement& rep, int eCode);
- void verifiedGetResponse(int eCode);
- void registerDevicePresence();
- void * timeOutCB(unsigned int msg);
- void * pollingCB(unsigned int msg);
-
- std::unique_ptr<std::list<BrokerRequesterInfoPtr>> requesterList;
- PrimitiveResourcePtr primitiveResource;
- PrimitiveTimer primitiveTimer;
-
- BROKER_STATE state;
- BROKER_MODE mode;
-
- bool isWithinTime;
- std::atomic_bool isTimeoutCB;
- std::atomic_long receivedTime;
- unsigned int timeoutHandle;
-
- RequestGetCB pGetCB;
- TimeoutCB pTimeoutCB;
- TimeoutCB pPollingCB;
-
-};
+ namespace Service
+ {
+ class ResourcePresence
+ {
+ public:
+ ResourcePresence();
+ ~ResourcePresence();
+
+ void initializeResourcePresence(PrimitiveResourcePtr pResource);
+
+ void addBrokerRequester(BrokerID _id, BrokerCB _cb);
+ void removeBrokerRequester(BrokerID _id);
+ void removeAllBrokerRequester();
+
+ void requestResourceState() const;
+ void changePresenceMode(BROKER_MODE newMode);
+
+ bool isEmptyRequester() const;
+
+ const PrimitiveResourcePtr getPrimitiveResource() const;
+ BROKER_STATE getResourceState() const;
+
+ private:
+ std::unique_ptr<std::list<BrokerRequesterInfoPtr>> requesterList;
+ PrimitiveResourcePtr primitiveResource;
+ PrimitiveTimer primitiveTimer;
+
+ BROKER_STATE state;
+ BROKER_MODE mode;
+
+ bool isWithinTime;
+ std::atomic_bool isTimeoutCB;
+ std::atomic_long receivedTime;
+ std::mutex cbMutex;
+ std::condition_variable cbCondition;
+ unsigned int timeoutHandle;
+
+ RequestGetCB pGetCB;
+ TimeoutCB pTimeoutCB;
+ TimeoutCB pPollingCB;
+
+ void registerDevicePresence();
+ void getCB(const HeaderOptions &hos, const ResponseStatement& rep, int eCode);
+ void verifiedGetResponse(int eCode);
+
+ void * timeOutCB(unsigned int msg);
+ void * pollingCB(unsigned int msg = 0);
+
+ void executeAllBrokerCB(BROKER_STATE changedState);
+ void setResourcestate(BROKER_STATE _state);
+ };
+ } // namespace Service
+} // namespace OIC
#endif /* RESOURCEPRESENCE_H_ */
#include "DeviceAssociation.h"
#include "DevicePresence.h"
-DeviceAssociation * DeviceAssociation::s_instance = nullptr;
-std::mutex DeviceAssociation::s_mutexForCreation;
-std::list< DevicePresencePtr > DeviceAssociation::s_deviceList;
-DeviceAssociation::DeviceAssociation()
+namespace OIC
{
- // TODO Auto-generated constructor stub
-}
+ namespace Service
+ {
+ DeviceAssociation * DeviceAssociation::s_instance = nullptr;
+ std::mutex DeviceAssociation::s_mutexForCreation;
+ std::list< DevicePresencePtr > DeviceAssociation::s_deviceList;
-DeviceAssociation::~DeviceAssociation()
-{
- // TODO Auto-generated destructor stub
-}
+ DeviceAssociation::DeviceAssociation()
+ {
+ // TODO Auto-generated constructor stub
+ }
-DeviceAssociation * DeviceAssociation::getInstance()
-{
- if (!s_instance)
- {
- s_mutexForCreation.lock();
- if (!s_instance)
+ DeviceAssociation::~DeviceAssociation()
{
- s_instance = new DeviceAssociation();
+ // TODO Auto-generated destructor stub
}
- s_mutexForCreation.unlock();
- }
- return s_instance;
-}
-DevicePresencePtr DeviceAssociation::findDevice(const std::string & address)
-{
- DevicePresencePtr retDevice = nullptr;
- for(auto it : s_deviceList)
- {
- if(address == it->getAddress())
+ DeviceAssociation * DeviceAssociation::getInstance()
{
- retDevice = it;
+ if (!s_instance)
+ {
+ s_mutexForCreation.lock();
+ if (!s_instance)
+ {
+ s_instance = new DeviceAssociation();
+ }
+ s_mutexForCreation.unlock();
+ }
+ return s_instance;
}
- }
- return retDevice;
-}
+ DevicePresencePtr DeviceAssociation::findDevice(const std::string & address)
+ {
+ DevicePresencePtr retDevice = nullptr;
+ for(auto it : s_deviceList)
+ {
+ if(address == it->getAddress())
+ {
+ retDevice = it;
+ }
+ }
-void DeviceAssociation::addDevice(DevicePresencePtr dPresence)
-{
- DevicePresencePtr foundDevice = findDevice(dPresence->getAddress());
- if(foundDevice == nullptr)
- {
- s_deviceList.push_back(dPresence);
- }
-}
+ return retDevice;
+ }
-void DeviceAssociation::removeDevice(DevicePresencePtr dPresence)
-{
- DevicePresencePtr foundDevice = findDevice(dPresence->getAddress());
- if(foundDevice != nullptr)
- {
- s_deviceList.remove(foundDevice);
- foundDevice.reset();
- }
-}
+ void DeviceAssociation::addDevice(DevicePresencePtr dPresence)
+ {
+ DevicePresencePtr foundDevice = findDevice(dPresence->getAddress());
+ if(foundDevice == nullptr)
+ {
+ s_deviceList.push_back(dPresence);
+ }
+ }
+
+ void DeviceAssociation::removeDevice(DevicePresencePtr dPresence)
+ {
+ DevicePresencePtr foundDevice = findDevice(dPresence->getAddress());
+ if(foundDevice != nullptr)
+ {
+ s_deviceList.remove(foundDevice);
+ foundDevice.reset();
+ }
+ }
+ } // namespace Service
+} // namespace OIC
#include "DevicePresence.h"
#include "PrimitiveException.h"
-DevicePresence::DevicePresence(PrimitiveResourcePtr pResource)
+namespace OIC
{
- pSubscribeRequestCB = std::bind(&DevicePresence::subscribeCB, this,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
-
- const char* log = pResource->getHost().c_str();
- OC_LOG_V(DEBUG, BROKER_TAG, "%s",log);
-
- try
+ namespace Service
{
- presenceSubscriber
- = PresenceSubscriber(pResource->getHost(), BROKER_TRANSPORT, pSubscribeRequestCB);
-
- OC_LOG_V(DEBUG, BROKER_TAG, "subscribe Presence");
- } catch(PrimitiveException & e)
- {
- OC_LOG_V(DEBUG, BROKER_TAG, "exception in subscribe Presence %s",e.what());
- }
-
- state = DEVICE_STATE::REQUESTED;
- pTimeoutCB = std::bind(&DevicePresence::timeOutCB, this, std::placeholders::_1);
- isWithinTime = true;
- //TODO generate Timer(if(!isTimer))
-}
+ DevicePresence::DevicePresence()
+ {
+ state = DEVICE_STATE::REQUESTED;
+ isWithinTime = true;
+ pSubscribeRequestCB = std::bind(&DevicePresence::subscribeCB, this,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
+ pTimeoutCB = std::bind(&DevicePresence::timeOutCB, this, std::placeholders::_1);
+ }
-DevicePresence::~DevicePresence()
-{
- resourcePresenceList.clear();
-}
+ DevicePresence::~DevicePresence()
+ {
+ resourcePresenceList.clear();
+ }
-const std::string DevicePresence::getAddress() const
-{
- return address;
-}
+ void DevicePresence::initializeDevicePresence(PrimitiveResourcePtr pResource)
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "%s",pResource->getHost().c_str());
+
+ try
+ {
+ presenceSubscriber
+ = PresenceSubscriber(pResource->getHost(), BROKER_TRANSPORT, pSubscribeRequestCB);
+
+ OC_LOG_V(DEBUG, BROKER_TAG, "subscribe Presence");
+ } catch(PrimitiveException & e)
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "exception in subscribe Presence %s",e.what());
+ throw PrimitiveException(e);
+ }
+ //TODO generate Timer(if(!isTimer))
+ }
-void DevicePresence::addPresenceResource(ResourcePresence * rPresence)
-{
- resourcePresenceList.push_back(rPresence);
-}
+ const std::string DevicePresence::getAddress() const
+ {
+ return address;
+ }
-void DevicePresence::removePresenceResource(ResourcePresence * rPresence)
-{
- resourcePresenceList.remove(rPresence);
-}
+ void DevicePresence::addPresenceResource(ResourcePresence * rPresence)
+ {
+ resourcePresenceList.push_back(rPresence);
+ }
-void DevicePresence::requestAllResourcePresence()
-{
- for(auto it : resourcePresenceList)
- {
- it->requestResourceState();
- }
-}
+ void DevicePresence::removePresenceResource(ResourcePresence * rPresence)
+ {
+ resourcePresenceList.remove(rPresence);
+ }
-bool DevicePresence::isEmptyResourcePresence() const
-{
- return resourcePresenceList.empty();
-}
+ void DevicePresence::requestAllResourcePresence()
+ {
+ for(auto it : resourcePresenceList)
+ {
+ it->requestResourceState();
+ }
+ }
-void DevicePresence::subscribeCB(OCStackResult ret,
- const unsigned int seq, const std::string& hostAddress)
-{
- const char* log = hostAddress.c_str();
- OC_LOG_V(DEBUG, BROKER_TAG, "Received presence CB from: %s",log);
- OC_LOG_V(DEBUG, BROKER_TAG, "In subscribeCB: %d",ret);
+ bool DevicePresence::isEmptyResourcePresence() const
+ {
+ return resourcePresenceList.empty();
+ }
- if(isWithinTime)
- {
- switch(ret)
+ void DevicePresence::subscribeCB(OCStackResult ret,
+ const unsigned int seq, const std::string& hostAddress)
{
- case OC_STACK_OK:
- case OC_STACK_RESOURCE_CREATED:
- case OC_STACK_CONTINUE:
- OC_LOG_V(DEBUG, BROKER_TAG, "SEQ# %d",seq);
- state = DEVICE_STATE::ALIVE;
- OC_LOG_V(DEBUG, BROKER_TAG, "device state : %d",(int)state);
- if(!resourcePresenceList.empty())
- {
- requestAllResourcePresence();
- }
- break;
-
- case OC_STACK_INVALID_REQUEST_HANDLE:
- case OC_STACK_RESOURCE_DELETED:
- case OC_STACK_TIMEOUT:
- case OC_STACK_COMM_ERROR:
- //TODO get request
- state = DEVICE_STATE::REQUESTED;
- if(!resourcePresenceList.empty())
+ OC_LOG_V(DEBUG, BROKER_TAG, "Received presence CB from: %s",hostAddress.c_str());
+ OC_LOG_V(DEBUG, BROKER_TAG, "In subscribeCB: %d",ret);
+
+ if(isWithinTime)
+ {
+ switch(ret)
{
- OC_LOG_V(DEBUG, BROKER_TAG, "ready to execute requestAllResourcePresence()");
- requestAllResourcePresence();
+ case OC_STACK_OK:
+ case OC_STACK_RESOURCE_CREATED:
+ case OC_STACK_CONTINUE:
+ OC_LOG_V(DEBUG, BROKER_TAG, "SEQ# %d",seq);
+ state = DEVICE_STATE::ALIVE;
+ OC_LOG_V(DEBUG, BROKER_TAG, "device state : %d",(int)state);
+ if(!resourcePresenceList.empty())
+ {
+ requestAllResourcePresence();
+ }
+ break;
+
+ case OC_STACK_INVALID_REQUEST_HANDLE:
+ case OC_STACK_RESOURCE_DELETED:
+ case OC_STACK_TIMEOUT:
+ case OC_STACK_COMM_ERROR:
+ //TODO get request
+ state = DEVICE_STATE::REQUESTED;
+ if(!resourcePresenceList.empty())
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG,
+ "ready to execute requestAllResourcePresence()");
+ requestAllResourcePresence();
+ }
+ break;
+
+ case OC_STACK_PRESENCE_STOPPED:
+ case OC_STACK_PRESENCE_TIMEOUT:
+ OC_LOG_V(DEBUG, BROKER_TAG, "Server Presence Stop!!");
+ state = DEVICE_STATE::LOST_SIGNAL;
+ requestAllResourcePresence();
+ break;
+
+ case OC_STACK_PRESENCE_DO_NOT_HANDLE:
+ OC_LOG_V(DEBUG, BROKER_TAG, "Presence Lost Signal because do not handled");
+ state = DEVICE_STATE::LOST_SIGNAL;
+ requestAllResourcePresence();
+ break;
+
+ default:
+ OC_LOG_V(DEBUG, BROKER_TAG, "Presence Lost Signal because unknown type");
+ state = DEVICE_STATE::LOST_SIGNAL;
+ requestAllResourcePresence();
+ break;
}
- break;
-
- case OC_STACK_PRESENCE_STOPPED:
- case OC_STACK_PRESENCE_TIMEOUT:
- OC_LOG_V(DEBUG, BROKER_TAG, "Server Presence Stop!!");
- state = DEVICE_STATE::LOST_SIGNAL;
- requestAllResourcePresence();
- break;
-
- case OC_STACK_PRESENCE_DO_NOT_HANDLE:
- OC_LOG_V(DEBUG, BROKER_TAG, "Presence Lost Signal because do not handled");
- state = DEVICE_STATE::LOST_SIGNAL;
- requestAllResourcePresence();
- break;
-
- default:
- OC_LOG_V(DEBUG, BROKER_TAG, "Presence Lost Signal because unknown type");
- state = DEVICE_STATE::LOST_SIGNAL;
- requestAllResourcePresence();
- break;
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "This response is Timeout but device steel alive");
+ this->state = DEVICE_STATE::ALIVE;
+ isWithinTime = true;
+ }
}
- }
- else
- {
- OC_LOG_V(DEBUG, BROKER_TAG, "This response is Timeout but device steel alive");
- this->state = DEVICE_STATE::ALIVE;
- isWithinTime = true;
- }
-}
-void * DevicePresence::timeOutCB(unsigned int msg)
-{
- this->isWithinTime = false;
- OC_LOG_V(DEBUG, BROKER_TAG, "Timeout execution. will be discard after receiving cb message");
- state = DEVICE_STATE::LOST_SIGNAL;
+ void * DevicePresence::timeOutCB(unsigned int msg)
+ {
+ this->isWithinTime = false;
+ OC_LOG_V(DEBUG, BROKER_TAG,
+ "Timeout execution. will be discard after receiving cb message");
+ state = DEVICE_STATE::LOST_SIGNAL;
- return NULL;
-}
+ return NULL;
+ }
+ } // namespace Service
+} // namespace OIC
#include "BrokerTypes.h"
#include "ResourceBroker.h"
-ResourceBroker * ResourceBroker::s_instance = NULL;
-std::mutex ResourceBroker::s_mutexForCreation;
-std::unique_ptr<PresenceList> ResourceBroker::s_presenceList(nullptr);
-std::unique_ptr<BrokerIDMap> ResourceBroker::s_brokerIDMap(nullptr);
-
-ResourceBroker::ResourceBroker()
+namespace OIC
{
- if(s_presenceList == nullptr)
- {
- s_presenceList = std::unique_ptr<PresenceList>(new PresenceList);
- }
- if(s_brokerIDMap == nullptr)
+ namespace Service
{
- s_brokerIDMap = std::unique_ptr<BrokerIDMap>(new BrokerIDMap);
- }
-}
+ ResourceBroker * ResourceBroker::s_instance = NULL;
+ std::mutex ResourceBroker::s_mutexForCreation;
+ std::unique_ptr<PresenceList> ResourceBroker::s_presenceList(nullptr);
+ std::unique_ptr<BrokerIDMap> ResourceBroker::s_brokerIDMap(nullptr);
-ResourceBroker::~ResourceBroker()
-{
- if(s_presenceList != nullptr)
- {
- s_presenceList->erase(s_presenceList->begin(), s_presenceList->end());
- s_presenceList->clear();
- }
- if(s_brokerIDMap != nullptr)
- {
- s_brokerIDMap->erase(s_brokerIDMap->begin(), s_brokerIDMap->end());
- s_brokerIDMap->clear();
- }
-}
-
-ResourceBroker * ResourceBroker::getInstance()
-{
- if (!s_instance)
- {
- s_mutexForCreation.lock();
- if (!s_instance)
+ ResourceBroker::~ResourceBroker()
{
- s_instance = new ResourceBroker();
+ if(s_presenceList != nullptr)
+ {
+ s_presenceList->erase(s_presenceList->begin(), s_presenceList->end());
+ s_presenceList->clear();
+ }
+ if(s_brokerIDMap != nullptr)
+ {
+ s_brokerIDMap->erase(s_brokerIDMap->begin(), s_brokerIDMap->end());
+ s_brokerIDMap->clear();
+ }
}
- s_mutexForCreation.unlock();
- }
- return s_instance;
-}
-
-BrokerID ResourceBroker::hostResource(PrimitiveResourcePtr pResource, BrokerCB cb)
-{
- BrokerID retID = 0;
- if (pResource->getUri().empty() || pResource->getHost().empty())
- {
- return retID;
- }
- if (cb == NULL)
- {
- return retID;
- }
-
- retID = generateBrokerID();
+ ResourceBroker * ResourceBroker::getInstance()
+ {
+ if (!s_instance)
+ {
+ s_mutexForCreation.lock();
+ if (!s_instance)
+ {
+ s_instance = new ResourceBroker();
+ s_instance->initializeResourceBroker();
+ }
+ s_mutexForCreation.unlock();
+ }
+ return s_instance;
+ }
- ResourcePresencePtr presenceItem = findResourcePresence(pResource);
- if(presenceItem == nullptr)
- {
- OC_LOG_V(DEBUG, BROKER_TAG, "Not found any Handled Resource.");
- OC_LOG_V(DEBUG, BROKER_TAG, "Create New Resource Presence Handler.");
+ const BrokerID ResourceBroker::hostResource(PrimitiveResourcePtr pResource, BrokerCB cb)
+ {
+ if(pResource == nullptr || cb == nullptr || cb == NULL)
+ {
+ throw InvalidParameter("[hostResource] input PrimitiveResource is Invalid");
+ }
- presenceItem = ResourcePresencePtr(new ResourcePresence(pResource));
- s_presenceList->push_back(presenceItem);
- }
- presenceItem->addBrokerRequester(retID, cb);
+ BrokerID retID = generateBrokerID();
- BrokerCBResourcePair pair(presenceItem, cb);
- s_brokerIDMap->insert(std::pair<BrokerID, BrokerCBResourcePair>
- (retID, BrokerCBResourcePair(presenceItem, cb)));
+ ResourcePresencePtr presenceItem = findResourcePresence(pResource);
+ if(presenceItem == nullptr)
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "Not found any Handled Resource.");
+ OC_LOG_V(DEBUG, BROKER_TAG, "Create New Resource Presence Handler.");
+
+ presenceItem.reset(new ResourcePresence());
+ presenceItem->initializeResourcePresence(pResource);
+ if(s_presenceList != nullptr)
+ {
+ s_presenceList->push_back(presenceItem);
+ }
+ }
+ presenceItem->addBrokerRequester(retID, cb);
- return retID;
-}
+ BrokerCBResourcePair pair(presenceItem, cb);
+ s_brokerIDMap->insert(std::pair<BrokerID, BrokerCBResourcePair>
+ (retID, BrokerCBResourcePair(presenceItem, cb)));
-BrokerID ResourceBroker::cancelHostResource(BrokerID brokerId)
-{
- BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
- if(brokerId == 0)
- {
- // input parameter is wrong.
- // hostResource never return value 0;
- return brokerId;
- }
- else if(it == s_brokerIDMap->end())
- {
- // not found requested brokerId in BrokerMap;
- return brokerId;
- }
- else
- {
- ResourcePresencePtr presenceItem = it->second.pResource;
- presenceItem->removeBrokerRequester(brokerId);
- s_brokerIDMap->erase(brokerId);
+ return retID;
+ }
- if(presenceItem->isEmptyRequester())
+ void ResourceBroker::cancelHostResource(BrokerID brokerId)
{
- auto iter = std::find(s_presenceList->begin(), s_presenceList->end(), presenceItem);
- s_presenceList->erase(iter);
- presenceItem.reset();
+ if(brokerId == 0)
+ {
+ // input parameter is wrong.
+ // hostResource never return value 0;
+ throw InvalidParameter("[cancelHostResource] input BrokerID is Invalid");
+ }
+
+ BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
+ if(it == s_brokerIDMap->end())
+ {
+ // not found requested brokerId in BrokerMap;
+ throw InvalidParameter("[cancelHostResource] input BrokerID is unknown ID");
+ }
+ else
+ {
+ ResourcePresencePtr presenceItem = it->second.pResource;
+ presenceItem->removeBrokerRequester(brokerId);
+ s_brokerIDMap->erase(brokerId);
+
+ if(presenceItem->isEmptyRequester())
+ {
+ auto iter = std::find(s_presenceList->begin(),
+ s_presenceList->end(), presenceItem);
+ s_presenceList->erase(iter);
+ presenceItem.reset();
+ }
+ }
}
- }
- return brokerId;
-}
+ BROKER_STATE ResourceBroker::getResourceState(BrokerID brokerId)
+ {
+ if(brokerId == 0)
+ {
+ throw InvalidParameter("[getResourceState] input BrokerID is Invalid");
+ }
-BROKER_STATE ResourceBroker::getResourceState(BrokerID brokerId)
-{
- BROKER_STATE retState = BROKER_STATE::NONE;
+ BROKER_STATE retState = BROKER_STATE::NONE;
- BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
- if(it != s_brokerIDMap->end())
- {
- ResourcePresencePtr foundResource = it->second.pResource;
- retState = foundResource->getResourceState();
- }
+ BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
+ if(it == s_brokerIDMap->end())
+ {
+ // not found requested brokerId in BrokerMap;
+ throw InvalidParameter("[getResourceState] input BrokerID is unknown ID");
+ }
+ else
+ {
+ ResourcePresencePtr foundResource = it->second.pResource;
+ retState = foundResource->getResourceState();
+ }
- return retState;
-}
+ return retState;
+ }
-BROKER_STATE ResourceBroker::getResourceState(PrimitiveResourcePtr pResource)
-{
- BROKER_STATE retState = BROKER_STATE::NONE;
+ BROKER_STATE ResourceBroker::getResourceState(PrimitiveResourcePtr pResource)
+ {
+ if(pResource == nullptr)
+ {
+ throw InvalidParameter("[getResourceState] input PrimitiveResource is Invalid");
+ }
- ResourcePresencePtr foundResource = findResourcePresence(pResource);
- if(foundResource != nullptr)
- {
- retState = foundResource->getResourceState();
- }
+ BROKER_STATE retState = BROKER_STATE::NONE;
- return retState;
-}
+ ResourcePresencePtr foundResource = findResourcePresence(pResource);
+ if(foundResource != nullptr)
+ {
+ retState = foundResource->getResourceState();
+ }
-ResourcePresencePtr ResourceBroker::findResourcePresence(PrimitiveResourcePtr pResource)
-{
- ResourcePresencePtr retResource(nullptr);
+ return retState;
+ }
- if(s_presenceList->empty() != true)
- {
- for(auto & it : * s_presenceList)
+ void ResourceBroker::initializeResourceBroker()
{
- PrimitiveResourcePtr temp = it->getPrimitiveResource();
- if(temp == pResource)
+ if(s_presenceList == nullptr)
{
- retResource = it;
- break;
+ s_presenceList = std::unique_ptr<PresenceList>(new PresenceList);
+ }
+ if(s_brokerIDMap == nullptr)
+ {
+ s_brokerIDMap = std::unique_ptr<BrokerIDMap>(new BrokerIDMap);
}
}
- }
- return retResource;
-}
+ ResourcePresencePtr ResourceBroker::findResourcePresence(PrimitiveResourcePtr pResource)
+ {
+ ResourcePresencePtr retResource(nullptr);
-BrokerID ResourceBroker::generateBrokerID()
-{
- BrokerID retID = 0;
- srand(time(NULL));
+ if(s_presenceList->empty() != true)
+ {
+ for(auto & it : * s_presenceList)
+ {
+ PrimitiveResourcePtr temp = it->getPrimitiveResource();
+ if(temp == pResource)
+ {
+ retResource = it;
+ break;
+ }
+ }
+ }
- while(1)
- {
- if(retID == 0 || s_brokerIDMap->find(retID) != s_brokerIDMap->end())
- {
- retID = (unsigned int)rand();
+ return retResource;
}
- else
+
+ BrokerID ResourceBroker::generateBrokerID()
{
- break;
+ BrokerID retID = 0;
+ srand(time(NULL));
+
+ while(1)
+ {
+ if(retID != 0 && s_brokerIDMap->find(retID) == s_brokerIDMap->end())
+ {
+ break;
+ }
+ retID = (unsigned int)rand();
+ }
+
+ return retID;
}
- }
- return retID;
-}
+ } // namespace Service
+} // namespace OIC
#include <exception>
#include <iostream>
#include <memory>
-#include <strstream>
#include "PrimitiveResource.h"
#include "DeviceAssociation.h"
#include "DevicePresence.h"
-ResourcePresence::ResourcePresence(PrimitiveResourcePtr pResource)
+namespace OIC
{
- primitiveResource = pResource;
- isTimeoutCB = false;
- receivedTime = 0L;
- pGetCB = std::bind(&ResourcePresence::getCB, this,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
- pTimeoutCB = std::bind(&ResourcePresence::timeOutCB, this,std::placeholders::_1);
- pPollingCB = std::bind(&ResourcePresence::pollingCB, this,std::placeholders::_1);
+ namespace Service
+ {
+ ResourcePresence::ResourcePresence()
+ {
+ primitiveResource = nullptr;
+ isTimeoutCB = false;
+ receivedTime = 0L;
+ state = BROKER_STATE::REQUESTED;
+ isWithinTime = true;
+ mode = BROKER_MODE::NON_PRESENCE_MODE;
- requesterList
- = std::unique_ptr<std::list<BrokerRequesterInfoPtr>>(new std::list<BrokerRequesterInfoPtr>);
+ requesterList = nullptr;
- timeoutHandle = primitiveTimer.requestTimer(SAFE_TIME, pTimeoutCB);
+ pGetCB = std::bind(&ResourcePresence::getCB, this,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
+ pTimeoutCB = std::bind(&ResourcePresence::timeOutCB, this,std::placeholders::_1);
+ pPollingCB = std::bind(&ResourcePresence::pollingCB, this,std::placeholders::_1);
+ }
- state = BROKER_STATE::REQUESTED;
- isWithinTime = true;
+ void ResourcePresence::initializeResourcePresence(PrimitiveResourcePtr pResource)
+ {
+ primitiveResource = pResource;
+ requesterList
+ = std::unique_ptr<std::list<BrokerRequesterInfoPtr>>
+ (new std::list<BrokerRequesterInfoPtr>);
- mode = BROKER_MODE::NON_PRESENCE_MODE;
- primitiveResource->requestGet(pGetCB);
+ timeoutHandle = primitiveTimer.requestTimer(SAFE_TIME, pTimeoutCB);
- registerDevicePresence();
-}
+ primitiveResource->requestGet(pGetCB);
-void ResourcePresence::registerDevicePresence()
-{
- std::string deviceAddress = primitiveResource->getHost();
-
- DevicePresencePtr foundDevice
- = DeviceAssociation::getInstance()->findDevice(deviceAddress);
+ registerDevicePresence();
+ }
- if(foundDevice == nullptr)
- {
- foundDevice = DevicePresencePtr(new DevicePresence(primitiveResource));
- DeviceAssociation::getInstance()->addDevice(foundDevice);
- }
- foundDevice->addPresenceResource(this);
-}
-ResourcePresence::~ResourcePresence()
-{
- std::string deviceAddress = primitiveResource->getHost();
+ ResourcePresence::~ResourcePresence()
+ {
+ std::string deviceAddress = primitiveResource->getHost();
- DevicePresencePtr foundDevice
- = DeviceAssociation::getInstance()->findDevice(deviceAddress);
+ DevicePresencePtr foundDevice
+ = DeviceAssociation::getInstance()->findDevice(deviceAddress);
- if(foundDevice != nullptr)
- {
- foundDevice->removePresenceResource(this);
+ if(foundDevice != nullptr)
+ {
+ foundDevice->removePresenceResource(this);
- if(foundDevice->isEmptyResourcePresence())
- {
- DeviceAssociation::getInstance()->removeDevice(foundDevice);
- }
- }
+ if(foundDevice->isEmptyResourcePresence())
+ {
+ DeviceAssociation::getInstance()->removeDevice(foundDevice);
+ }
+ }
- requesterList->clear();
+ requesterList->clear();
- state = BROKER_STATE::DESTROYED;
-}
+ state = BROKER_STATE::DESTROYED;
+ }
-void ResourcePresence::addBrokerRequester(BrokerID _id, BrokerCB _cb)
-{
- BrokerRequesterInfoPtr newRequester = BrokerRequesterInfoPtr(new BrokerRequesterInfo());
- newRequester->brockerId = _id;
- newRequester->brockerCB = _cb;
- requesterList->push_back(newRequester);
-}
+ void ResourcePresence::addBrokerRequester(BrokerID _id, BrokerCB _cb)
+ {
+ BrokerRequesterInfoPtr newRequester;
+ newRequester.reset(new BrokerRequesterInfo());
-void ResourcePresence::removeAllBrokerRequester()
-{
- requesterList->erase(requesterList->begin(), requesterList->end());
-}
+ newRequester->brockerId = _id;
+ newRequester->brockerCB = _cb;
+ requesterList->push_back(newRequester);
+ }
-void ResourcePresence::removeBrokerRequester(BrokerID _id)
-{
- std::list<BrokerRequesterInfoPtr>::iterator iter = requesterList->begin();
- for(; iter != requesterList->end(); ++iter)
- {
- if(iter->get()->brockerId == _id)
+ void ResourcePresence::removeAllBrokerRequester()
{
- requesterList->erase(iter);
- break;
+ if(requesterList != nullptr)
+ {
+ requesterList->erase(requesterList->begin(), requesterList->end());
+ }
}
- }
-}
-bool ResourcePresence::isEmptyRequester() const
-{
- return requesterList->empty();
-}
+ void ResourcePresence::removeBrokerRequester(BrokerID _id)
+ {
+ std::list<BrokerRequesterInfoPtr>::iterator iter = requesterList->begin();
+ for(; iter != requesterList->end(); ++iter)
+ {
+ if(iter->get()->brockerId == _id)
+ {
+ requesterList->erase(iter);
+ break;
+ }
+ }
+ }
-void ResourcePresence::requestResourceState()
-{
- OC_LOG_V(DEBUG, BROKER_TAG, "Request Get\n");
- primitiveResource->requestGet(pGetCB);
-}
+ bool ResourcePresence::isEmptyRequester() const
+ {
+ return requesterList->empty();
+ }
-void ResourcePresence::executeAllBrokerCB(BROKER_STATE changedState)
-{
- OC_LOG_V(DEBUG, BROKER_TAG, "executeAllBrokerCB()");
- if(state != changedState)
- {
- state = changedState;
- for(BrokerRequesterInfoPtr & item : * requesterList)
+ void ResourcePresence::requestResourceState() const
{
- item->brockerCB(state);
+ OC_LOG_V(DEBUG, BROKER_TAG, "Request Get\n");
+ primitiveResource->requestGet(pGetCB);
}
- }
-}
-void ResourcePresence::setResourcestate(BROKER_STATE _state)
-{
- this->state = _state;
+ void ResourcePresence::registerDevicePresence()
+ {
+ std::string deviceAddress = primitiveResource->getHost();
-}
+ DevicePresencePtr foundDevice
+ = DeviceAssociation::getInstance()->findDevice(deviceAddress);
-void * ResourcePresence::timeOutCB(unsigned int msg)
-{
- isTimeoutCB = true;
+ if(foundDevice == nullptr)
+ {
+ foundDevice.reset(new DevicePresence());
+ foundDevice->initializeDevicePresence(primitiveResource);
+ DeviceAssociation::getInstance()->addDevice(foundDevice);
+ }
+ foundDevice->addPresenceResource(this);
+ }
- time_t currentTime;
- time(¤tTime);
- currentTime+=0L;
+ void ResourcePresence::executeAllBrokerCB(BROKER_STATE changedState)
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "executeAllBrokerCB()");
+ if(state != changedState)
+ {
+ setResourcestate(changedState);
+ if(requesterList->empty() != true)
+ {
+ for(BrokerRequesterInfoPtr & item : * requesterList)
+ {
+ item->brockerCB(state);
+ }
+ }
+ }
+ }
- if((receivedTime == 0L) || ((receivedTime+SAFE_TIME) > currentTime))
- {
- return NULL;
- }
- this->isWithinTime = false;
- OC_LOG_V(DEBUG, BROKER_TAG, "Timeout execution. will be discard after receiving cb message");
+ void ResourcePresence::setResourcestate(BROKER_STATE _state)
+ {
+ this->state = _state;
- executeAllBrokerCB(BROKER_STATE::LOST_SIGNAL);
- pollingCB(0);
+ }
- isTimeoutCB = false;
+ void * ResourcePresence::timeOutCB(unsigned int msg)
+ {
+ std::unique_lock<std::mutex> lock(cbMutex);
+ isTimeoutCB = true;
- return NULL;
-}
+ time_t currentTime;
+ time(¤tTime);
+ currentTime+=0L;
-void * ResourcePresence::pollingCB(unsigned int msg)
-{
- this->requestResourceState();
- timeoutHandle = primitiveTimer.requestTimer(SAFE_TIME,pTimeoutCB);
+ if((receivedTime == 0L) || ((receivedTime+SAFE_TIME) > currentTime))
+ {
+ return NULL;
+ }
+ this->isWithinTime = false;
+ OC_LOG_V(DEBUG, BROKER_TAG,
+ "Timeout execution. will be discard after receiving cb message");
- return NULL;
-}
+ executeAllBrokerCB(BROKER_STATE::LOST_SIGNAL);
+ pollingCB();
-void ResourcePresence::getCB(const HeaderOptions &hos, const ResponseStatement& rep, int eCode)
-{
- OC_LOG_V(DEBUG, BROKER_TAG, "response getCB\n");
- while(isTimeoutCB)
- {
- OC_LOG_V(DEBUG, BROKER_TAG, "wait\n");
- sleep(2);
- }
- time_t currentTime;
- time(¤tTime);
- receivedTime = currentTime;
- try
- {
- state = BROKER_STATE::ALIVE;
- verifiedGetResponse(eCode);
+ isTimeoutCB = false;
+ cbCondition.notify_all();
- if(isWithinTime)
- {
- primitiveTimer.cancelTimer(timeoutHandle);
- isWithinTime = true;
+ return NULL;
}
- }
- catch(std::exception& e)
- {
-
- }
-
- if(mode == BROKER_MODE::NON_PRESENCE_MODE)
- {
- // TODO set timer & request get
- primitiveTimer.requestTimer(SAFE_TIME,pPollingCB);
- }
+ void * ResourcePresence::pollingCB(unsigned int msg)
+ {
+ this->requestResourceState();
+ timeoutHandle = primitiveTimer.requestTimer(SAFE_TIME,pTimeoutCB);
-}
+ return NULL;
+ }
-void ResourcePresence::verifiedGetResponse(int eCode)
-{
- switch(eCode)
- {
- case OC_STACK_OK:
- case OC_STACK_CONTINUE:
- state = BROKER_STATE::ALIVE;
- OC_LOG_V(DEBUG, BROKER_TAG, "resource state : %d",(int)state);
- break;
-
- case OC_STACK_INVALID_REQUEST_HANDLE:
- case OC_STACK_RESOURCE_DELETED:
- case OC_STACK_TIMEOUT:
- case OC_STACK_COMM_ERROR:
- case OC_STACK_PRESENCE_STOPPED:
- case OC_STACK_PRESENCE_TIMEOUT:
- if(!requesterList->empty())
+ void ResourcePresence::getCB(const HeaderOptions &hos,
+ const ResponseStatement& rep, int eCode)
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "response getCB\n");
+ while(isTimeoutCB)
{
- executeAllBrokerCB(BROKER_STATE::LOST_SIGNAL);
+ OC_LOG_V(DEBUG, BROKER_TAG, "waiting for terminate TimeoutCB\n");
+ std::unique_lock<std::mutex> lock(cbMutex);
+ cbCondition.wait(lock);
}
- else
+
+ time_t currentTime;
+ time(¤tTime);
+ receivedTime = currentTime;
+
+ verifiedGetResponse(eCode);
+
+ if(isWithinTime)
{
- setResourcestate(BROKER_STATE::LOST_SIGNAL);
+ primitiveTimer.cancelTimer(timeoutHandle);
+ isWithinTime = true;
}
- break;
- default:
- if(!requesterList->empty())
+ if(mode == BROKER_MODE::NON_PRESENCE_MODE)
{
- executeAllBrokerCB(BROKER_STATE::LOST_SIGNAL);
+ // TODO set timer & request get
+ primitiveTimer.requestTimer(SAFE_TIME,pPollingCB);
}
- else
+
+ }
+
+ void ResourcePresence::verifiedGetResponse(int eCode)
+ {
+ BROKER_STATE verifiedState = BROKER_STATE::NONE;
+ switch(eCode)
{
- setResourcestate(BROKER_STATE::LOST_SIGNAL);
+ case OC_STACK_OK:
+ case OC_STACK_CONTINUE:
+ verifiedState = BROKER_STATE::ALIVE;
+ break;
+
+ case OC_STACK_RESOURCE_DELETED:
+ verifiedState = BROKER_STATE::DESTROYED;
+ break;
+
+ case OC_STACK_INVALID_REQUEST_HANDLE:
+ case OC_STACK_TIMEOUT:
+ case OC_STACK_COMM_ERROR:
+ case OC_STACK_PRESENCE_STOPPED:
+ case OC_STACK_PRESENCE_TIMEOUT:
+ default:
+ verifiedState = BROKER_STATE::LOST_SIGNAL;
+ break;
}
- break;
- }
-}
-PrimitiveResourcePtr ResourcePresence::getPrimitiveResource()
-{
- return primitiveResource;
-}
+ executeAllBrokerCB(verifiedState);
+ OC_LOG_V(DEBUG, BROKER_TAG, "resource state : %d",(int)state);
+ }
-BROKER_STATE ResourcePresence::getResourceState()
-{
- return state;
-}
+ const PrimitiveResourcePtr ResourcePresence::getPrimitiveResource() const
+ {
+ return primitiveResource;
+ }
-void ResourcePresence::changePresenceMode(BROKER_MODE newMode)
-{
- if(newMode != mode)
- {
- if(newMode == BROKER_MODE::NON_PRESENCE_MODE)
+ BROKER_STATE ResourcePresence::getResourceState() const
{
- requestResourceState();
+ return state;
+ }
+
+ void ResourcePresence::changePresenceMode(BROKER_MODE newMode)
+ {
+ if(newMode != mode)
+ {
+ if(newMode == BROKER_MODE::NON_PRESENCE_MODE)
+ {
+ requestResourceState();
+ }
+ mode = newMode;
+ }
}
- mode = newMode;
- }
-}
+ } // namespace Service
+} // namespace OIC
projects / platform / upstream / iotivity.git / commitdiff