######################################################################
resourcebroker_env.AppendUnique(CPPPATH = ['include'])
resourcebroker_env.AppendUnique(CPPPATH = ['../common/primitiveResource/include'])
-resourcebroker_env.PrependUnique(LIBS = ['oc', 'octbstack', 'oc_logger', 'connectivity_abstraction', 'libcoap'])
+resourcebroker_env.AppendUnique(LIBPATH = [env.get('BUILD_DIR')])
+resourcebroker_env.PrependUnique(LIBS = ['ServiceCommon','oc', 'octbstack', 'oc_logger', 'connectivity_abstraction', 'libcoap'])
+
if target_os not in ['windows', 'winrt']:
- resourcebroker_env.AppendUnique(CXXFLAGS = ['-O2', '-g', '-Wall', '-fmessage-length=0', '-std=c++0x'])
+ resourcebroker_env.AppendUnique(CXXFLAGS = ['-O2', '-g', '-Wall', '-fmessage-length=0', '-std=c++0x'])
if target_os == 'linux':
- resourcebroker_env.AppendUnique(LIBS = ['pthread'])
+ resourcebroker_env.AppendUnique(LIBS = ['pthread'])
######################################################################
# Source files and Targets
######################################################################
-CACHE_SRC_DIR = 'src/'
+BROKER_SRC_DIR = 'src/'
resourcebroker_src = [
- CACHE_SRC_DIR + 'ResourceBroker.cpp',
- CACHE_SRC_DIR + 'ResourcePresence.cpp',
- CACHE_SRC_DIR + '../../common/primitiveResource/src/PrimitiveResource.cpp',
- CACHE_SRC_DIR + '../../common/primitiveResource/src/ResourceAttributes.cpp',
- CACHE_SRC_DIR + 'DevicePresence.cpp']
+ BROKER_SRC_DIR + 'ResourceBroker.cpp',
+ BROKER_SRC_DIR + 'ResourcePresence.cpp',
+ BROKER_SRC_DIR + 'DevicePresence.cpp']
+
if target_os in ['tizen','android'] :
resourcebrokersdk = resourcebroker_env.SharedLibrary('ResourceBroker', resourcebroker_src)
resourcebroker_env.InstallTarget(resourcebrokersdk, 'libResouceBroker')
# Go to build sample apps
-#SConscript('SampleApp/SConscript')
+SConscript('SampleApp/SConscript')
+
#include "OCPlatform.h"
#include "octypes.h"
+#include "logger.h"
#include "PrimitiveResource.h"
#define BROKER_TAG PCF("BROKER")
+
#define BROKER_TRANSPORT OCConnectivityType::OC_IPV4
+
struct BrokerRequesterInfo;
class ResourcePresence;
class DevicePresence;
typedef std::shared_ptr<ResourcePresence> ResourcePresencePtr;
typedef std::shared_ptr<DevicePresence> DevicePresencePtr;
-enum class DISCOVER_TRANSACTION
-{
- KEEP = 0,
- DELETE
-};
-
+/*
+ * @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
+ 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
+};
+
struct BrokerRequesterInfo
{
const std::string&)> SubscribeCallback;
typedef std::function<void(const HeaderOptions&, const ResponseStatement&, int)> GetCallback;
+typedef std::function<void(int)> TimeoutCallback;
#endif // BROKERTYPES_H_
#include "BrokerTypes.h"
#include "ResourcePresence.h"
+#include "PresenceSubscriber.h"
class DevicePresence
{
public:
DevicePresence(PrimitiveResourcePtr pResource, BrokerCB _cb);
+
+ DevicePresence();
~DevicePresence();
+ void createDevicePresence(PrimitiveResourcePtr pResource, BrokerCB _cb);
+
void addPresenceResource(PrimitiveResourcePtr pResource, BrokerCB _cb);
ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource, BrokerCB _cb);
+ ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource);
private:
-
SubscribeCallback pSubscribeRequestCB;
- std::unique_ptr<std::list<ResourcePresencePtr>> presenceResourceList;
- BasePresenceHandle presenceHandle;
- void subscribeCB(OCStackResult ret, const unsigned int seq, const std::string& msg);
+ std::unique_ptr<std::list<ResourcePresencePtr>> resourcePresenceList;
+
+ BasePresenceHandle presenceHandle;
+ PresenceSubscriber presenceSubscriber;
+ TimeoutCallback pTimeoutCB;
+ DEVICE_STATE state;
const std::string address;
+
+ void subscribeCB(OCStackResult ret,const unsigned int seq, const std::string& Hostaddress);
+ void requestAllResourcePresence();
+ bool isWithinTime;
+ void TimeOutCB(int msg);
+
};
#endif /* DEVICEPRESENCE_H_ */
class ResourceBroker
{
public:
- ResourceBroker * getInstance();
+ static ResourceBroker * getInstance();
OCStackResult hostResource(PrimitiveResourcePtr pResource, BrokerCB cb);
OCStackResult cancelHostResource(PrimitiveResourcePtr pResource);
- OCStackResult getResourceState(PrimitiveResourcePtr pResource);
+
+ BROKER_STATE getResourceState(PrimitiveResourcePtr pResource);
+
private:
ResourceBroker();
ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource, BrokerCB cb);
DevicePresencePtr findDevicePresence(PrimitiveResourcePtr pResource, BrokerCB cb);
+
+
+ ResourcePresencePtr findResourcePresence(PrimitiveResourcePtr pResource);
+
};
#endif /* RESOURCEBROKER_H_ */
void requestResourceState();
+ PrimitiveResourcePtr getPrimitiveResource();
+ BROKER_STATE getResourceState();
+ void setResourcestate(BROKER_STATE _state);
+ void executeAllBrokerCB();
+
private:
PrimitiveResourcePtr primitiveResource;
std::unique_ptr<std::list<BrokerRequesterInfoPtr>> requesterList;
+ BROKER_STATE state;
GetCallback pGetCB;
+ TimeoutCallback pTimeoutCB;
void GetCB(const HeaderOptions &hos, const ResponseStatement& rep, int seq);
+ bool isWithinTime;
+ void TimeOutCB(int msg);
+
};
#endif /* RESOURCEPRESENCE_H_ */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "DevicePresence.h"
+#include "PrimitiveException.h"
DevicePresence::DevicePresence(PrimitiveResourcePtr pResource, BrokerCB _cb)
{
- pSubscribeRequestCB = std::bind(&DevicePresence::subscribeCB, this,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
-
- presenceResourceList
- = std::unique_ptr<std::list<ResourcePresencePtr>>(new std::list<ResourcePresencePtr>);
- addPresenceResource(pResource, _cb);
+ createDevicePresence(pResource, _cb);
+}
- OC::OCPlatform::subscribePresence(presenceHandle, pResource->getHost(),
- BROKER_TRANSPORT, pSubscribeRequestCB);
+DevicePresence::DevicePresence()
+{
}
DevicePresence::~DevicePresence()
{
// TODO Auto-generated destructor stub
- OC::OCPlatform::unsubscribePresence(presenceHandle);
- presenceResourceList->clear();
+
+ resourcePresenceList->clear();
}
+void DevicePresence::createDevicePresence(PrimitiveResourcePtr pResource, BrokerCB _cb)
+{
+ 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
+ {
+ 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());
+ }
+ resourcePresenceList
+ = std::unique_ptr<std::list<ResourcePresencePtr>>(new std::list<ResourcePresencePtr>);
+
+ addPresenceResource(pResource, _cb);
+ state = DEVICE_STATE::REQUESTED;
+ pTimeoutCB = std::bind(&DevicePresence::TimeOutCB, this,
+ std::placeholders::_1);
+ //TODO generate Timer(if(!isTimer))
+ //register pTimeroutCB
+ this->isWithinTime = true;
+}
+void DevicePresence::TimeOutCB(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::addPresenceResource(PrimitiveResourcePtr pResource, BrokerCB _cb)
{
ResourcePresencePtr newPresenceResource = ResourcePresencePtr(new ResourcePresence(pResource, _cb));
- presenceResourceList->push_back(newPresenceResource);
+ resourcePresenceList->push_back(newPresenceResource);
+
}
ResourcePresencePtr DevicePresence::findResourcePresence(PrimitiveResourcePtr pResource, BrokerCB _cb)
{
ResourcePresencePtr retResource(nullptr);
- if (presenceResourceList->empty())// || pResource.isEmpty())
+
+ if (resourcePresenceList->empty())// || pResource.isEmpty())
{
return retResource;
}
std::list<ResourcePresencePtr>::iterator it;
ResourcePresencePtr temp = ResourcePresencePtr(new ResourcePresence(pResource, _cb));
- it = std::find(presenceResourceList->begin(), presenceResourceList->end(), temp);
-
- if(it == presenceResourceList->end())
+ it = std::find(resourcePresenceList->begin(), resourcePresenceList->end(), temp);
+ if(it == resourcePresenceList->end())
{
return retResource;
}
return retResource;
}
+ResourcePresencePtr DevicePresence::findResourcePresence(PrimitiveResourcePtr pResource)
+{
+ ResourcePresencePtr retResource(nullptr);
+ if (resourcePresenceList->empty())// || pResource.isEmpty())
+ {
+ return retResource;
+ }
+ else
+ {
+ for(auto & it : * resourcePresenceList)
+ {
+ if(it->getPrimitiveResource() == pResource)
+ {
+ retResource = it;
+ }
+ }
+ }
+ return retResource;
+}
+
+void DevicePresence::requestAllResourcePresence()
+{
+ std::list<ResourcePresencePtr>::iterator it;
+ for( auto & it : * resourcePresenceList)
+ {
+ it->requestResourceState();
+ }
+}
+
void DevicePresence::subscribeCB(OCStackResult ret,
- const unsigned int seq, const std::string& msg)
+ 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);
+ //TODO : cancel timer if(isTimer)
+ if(isWithinTime)
+ {
+ switch(ret)
+ {
+ 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;
+ for(auto & it : * resourcePresenceList)
+ {
+ it->setResourcestate(BROKER_STATE::LOST_SIGNAL);
+ it->executeAllBrokerCB();
+ }
+
+ 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;
+ break;
+ default:
+ state = DEVICE_STATE::LOST_SIGNAL;
+ break;
+ }
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "its message is not available because of Timeout msg");
+ this->state = DEVICE_STATE::ALIVE;
+ //notify cb message to user.
+ isWithinTime = true;
+ }
}
#define DEFAULT_CONTEXT_VALUE 0x99
ResourceBroker * ResourceBroker::s_instance = NULL;
+std::mutex ResourceBroker::s_mutexForCreation;
std::unique_ptr<std::list< DevicePresencePtr >> ResourceBroker::s_presenceList(nullptr);
ResourceBroker::ResourceBroker()
}
DevicePresencePtr presenceItem = findDevicePresence(pResource, cb);
- if(presenceItem == NULL)
+
+ if(presenceItem == nullptr)
{
- DevicePresencePtr newItem = DevicePresencePtr(new DevicePresence(pResource, cb));
+ OC_LOG_V(DEBUG, BROKER_TAG, "Not found any Handled Device.");
+ OC_LOG_V(DEBUG, BROKER_TAG, "Create New Device Presence Handler.");
+
+ DevicePresencePtr newItem = DevicePresencePtr(new DevicePresence());
+ newItem->createDevicePresence(pResource, cb);
+
s_presenceList->push_back(newItem);
}
else
return ret;
}
+OCStackResult ResourceBroker::cancelHostResource(PrimitiveResourcePtr pResource)
+{
+ return OC_STACK_OK;
+}
+
+BROKER_STATE ResourceBroker::getResourceState(PrimitiveResourcePtr pResource)
+{
+ BROKER_STATE retState = BROKER_STATE::NONE;
+
+ auto foundResource = findResourcePresence(pResource);
+
+ if(foundResource != nullptr)
+ {
+ retState = foundResource->getResourceState();
+ }
+ return retState;
+}
+
+
DevicePresencePtr ResourceBroker::findDevicePresence(PrimitiveResourcePtr pResource, BrokerCB cb)
{
DevicePresencePtr retDevice(nullptr);
return retResource;
}
+
+ResourcePresencePtr ResourceBroker::findResourcePresence(PrimitiveResourcePtr pResource)
+{
+ ResourcePresencePtr retResource(nullptr);
+ if (s_presenceList->empty())// || pResource->isEmpty())
+ {
+ return retResource;
+ }
+ else
+ {
+ for(auto & it : * s_presenceList)
+ {
+ auto temp = it->findResourcePresence(pResource);
+ if(temp != nullptr)
+ {
+ retResource = temp;
+ }
+ }
+ }
+
+ return retResource;
+}
pGetCB = std::bind(&ResourcePresence::GetCB, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
-
+ pTimeoutCB = std::bind(&ResourcePresence::TimeOutCB, this,
+ std::placeholders::_1);
requesterList
= std::unique_ptr<std::list<BrokerRequesterInfoPtr>>(new std::list<BrokerRequesterInfoPtr>);
-
+ //TODO generate Timer(if(!isTimer))
+ //register pTimeroutCB
addBrokerRequesterCB(_cb);
+ state = BROKER_STATE::REQUESTED;
+ this->isWithinTime = true;
}
ResourcePresence::~ResourcePresence()
{
requesterList->clear();
+
+ state = BROKER_STATE::DESTROYED;
}
void ResourcePresence::addBrokerRequesterCB(BrokerCB _cb)
void ResourcePresence::requestResourceState()
{
primitiveResource->requestGet(pGetCB);
+
+}
+void ResourcePresence::executeAllBrokerCB()
+{
+ OC_LOG_V(DEBUG, BROKER_TAG, "executeAllBrokerCB()");
+ for(BrokerRequesterInfoPtr & item : * requesterList)
+ {
+ item->brockerCB(this->state);
+ }
}
+void ResourcePresence::setResourcestate(BROKER_STATE _state)
+{
+ this->state = _state;
+
+}
+void ResourcePresence::TimeOutCB(int msg)
+{
+ this->isWithinTime = false;
+ OC_LOG_V(DEBUG, BROKER_TAG, "Timeout execution. will be discard after receiving cb message");
+ this->state = BROKER_STATE::LOST_SIGNAL;
+}
void ResourcePresence::GetCB(const HeaderOptions &hos, const ResponseStatement& rep, int seq)
{
+ try
+ {
+ //TODO : cancel timer if(isTimer)
+ if(isWithinTime)
+ {
+
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state :: %d",(int)state);
+ state = BROKER_STATE::ALIVE;
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state changed :: %d",(int)state);
+ OC_LOG_V(DEBUG, BROKER_TAG, "GET request was successful");
+
+ if(!requesterList->empty())
+ {
+ executeAllBrokerCB();
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "None exist resource for request");
+ state = BROKER_STATE::DESTROYED;
+ }
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "its message is not available because of Timeout msg");
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state :: %d",(int)state);
+ state = BROKER_STATE::ALIVE;
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state changed :: %d",(int)state);
+ OC_LOG_V(DEBUG, BROKER_TAG, "GET request was successful");
+ //notify cb message to user.
+ if(!requesterList->empty())
+ {
+ executeAllBrokerCB();
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "None exist resource for request");
+ state = BROKER_STATE::DESTROYED;
+ }
+ isWithinTime = true;
+ }
+ }
+ catch(std::exception& e)
+ {
+
+ }
+}
+/*
+ * TODO : getCB logic is not fixed until now. below logic will be used forwarding task.
+ *
+ * // if(eCode == OC_STACK_OK)
+// {
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state :: %d",(int)state);
+ state = BROKER_STATE::ALIVE;
+ OC_LOG_V(DEBUG, BROKER_TAG, "broker state changed :: %d",(int)state);
+ OC_LOG_V(DEBUG, BROKER_TAG, "GET request was successful");
+// std::cout << "[ResourcePresence]" << "Resource URI: " << rep.getUri() << std::endl;
+// }
+// else
+// {
+// std::cout << "[ResourcePresence]" << "onGET Response error: " << eCode << std::endl;
+ if(!requesterList->empty())
+ {
+ executeAllBrokerCB();
+ }
+ else
+ {
+ OC_LOG_V(DEBUG, BROKER_TAG, "None exist resource for request");
+ state = BROKER_STATE::DESTROYED;
+ }
+// }
+ */
+PrimitiveResourcePtr ResourcePresence::getPrimitiveResource()
+{
+ return primitiveResource;
+}
+
+BROKER_STATE ResourcePresence::getResourceState()
+{
+ return state;
}
projects / platform / upstream / iotivity.git / commitdiff