#include "OCUtilities.h"
#include "ocpayload.h"
+#include "logger.h"
#include "oc_logger.hpp"
+#define TAG "OIC_PLATFORM"
+
namespace OC
{
return s_config;
}
- void OCPlatform_impl::Configure(const PlatformConfig& config)
+ OCStackResult OCPlatform_impl::Configure(const PlatformConfig& config)
{
- OCRegisterPersistentStorageHandler(config.ps);
+ OIC_LOG_V(INFO, TAG, "Configure : %d %p", config.transportType, config.ps);
+ OCStackResult res = OC_STACK_OK;
+
+ res = OCSetSecurePSI(config.key, config.ps, config.psEnc, config.psRescue);
+ if (OC_STACK_OK == res && config.psEnc)
+ {
+ OIC_LOG(INFO, TAG, "It uses psEnc for svr db.");
+ res = OCRegisterPersistentStorageHandler(config.psEnc);
+ } else
+ {
+ OIC_LOG(INFO, TAG, "It uses ps for svr db.");
+ res = OCRegisterPersistentStorageHandler(config.ps);
+ }
+
globalConfig() = config;
+ return res;
}
OCPlatform_impl& OCPlatform_impl::Instance()
return platform;
}
+ OCStackResult OCPlatform_impl::start()
+ {
+ OIC_LOG(INFO, TAG, "start");
+
+ OCStackResult res = OC_STACK_OK;
+ if (OC_CLIENT == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::start))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else if (OC_SERVER == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::start))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else if (OC_CLIENT_SERVER == m_modeType || OC_GATEWAY == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::start))
+ {
+ res = OC_STACK_ERROR;
+ }
+
+ if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::start))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else
+ {
+ res = OC_STACK_ERROR;
+ }
+
+ return res;
+ }
+
+ OCStackResult OCPlatform_impl::stop()
+ {
+ OIC_LOG(INFO, TAG, "stop");
+
+ OCStackResult res = OC_STACK_OK;
+ if (OC_CLIENT == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::stop))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else if (OC_SERVER == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::stop))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else if (OC_CLIENT_SERVER == m_modeType)
+ {
+ if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::stop))
+ {
+ res = OC_STACK_ERROR;
+ }
+
+ if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::stop))
+ {
+ res = OC_STACK_ERROR;
+ }
+ }
+ else
+ {
+ res = OC_STACK_ERROR;
+ }
+
+ return res;
+ }
+
void OCPlatform_impl::init(const PlatformConfig& config)
{
+ OIC_LOG(INFO, TAG, "init");
+
switch(config.mode)
{
case ModeType::Server:
m_server = m_WrapperInstance->CreateServerWrapper(m_csdkLock, config);
+ m_modeType = OC_SERVER;
break;
case ModeType::Client:
m_client = m_WrapperInstance->CreateClientWrapper(m_csdkLock, config);
+ m_modeType = OC_CLIENT;
break;
case ModeType::Both:
case ModeType::Gateway:
m_server = m_WrapperInstance->CreateServerWrapper(m_csdkLock, config);
m_client = m_WrapperInstance->CreateClientWrapper(m_csdkLock, config);
+ m_modeType = OC_CLIENT_SERVER;
break;
}
}
OCStackResult OCPlatform_impl::notifyAllObservers(OCResourceHandle resourceHandle,
QualityOfService QoS)
{
- return result_guard(OCNotifyAllObservers(resourceHandle,
- static_cast<OCQualityOfService>(QoS)));
+ return checked_guard(m_server, &IServerWrapper::notifyAllObservers, resourceHandle, QoS);
}
OCStackResult OCPlatform_impl::notifyAllObservers(OCResourceHandle resourceHandle)
const std::shared_ptr<OCResourceResponse> pResponse,
QualityOfService QoS)
{
- if(!pResponse)
- {
- return result_guard(OC_STACK_ERROR);
- }
-
- OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload();
- OCStackResult result =
- OCNotifyListOfObservers(resourceHandle,
- &observationIds[0], observationIds.size(),
- pl,
- static_cast<OCQualityOfService>(QoS));
- OCRepPayloadDestroy(pl);
- return result_guard(result);
+ return checked_guard(m_server, &IServerWrapper::notifyListOfObservers, resourceHandle,
+ observationIds, pResponse, QoS);
}
OCResource::Ptr OCPlatform_impl::constructResourceObject(const std::string& host,
uri, "", connectivityType,
resourceProperty,
resourceTypes,
- interfaces));
+ interfaces, ""));
}
OCStackResult OCPlatform_impl::findResource(const std::string& host,
FindResListCallback resourceHandler,
QualityOfService QoS)
{
- return checked_guard(m_client, &IClientWrapper::ListenForResource2,
+ return checked_guard(m_client, &IClientWrapper::ListenForResourceList,
host, resourceName, connectivityType, resourceHandler, QoS);
}
+ OCStackResult OCPlatform_impl::findResourceList(const std::string& host,
+ const std::string& resourceName,
+ OCConnectivityType connectivityType,
+ FindResListCallback resourceHandler,
+ FindErrorCallback errorHandler,
+ QualityOfService Qos)
+ {
+ return checked_guard(m_client, &IClientWrapper::ListenForResourceListWithError,
+ host, resourceName, connectivityType, resourceHandler,
+ errorHandler, Qos);
+ }
+
OCStackResult OCPlatform_impl::getDeviceInfo(const std::string& host,
const std::string& deviceURI,
OCConnectivityType connectivityType,
connectivityType));
}
#endif // WITH_CLOUD
+#ifdef TCP_ADAPTER
+ OCStackResult OCPlatform_impl::findKeepAliveResource(std::string host, KeepAliveCallback resultCallback)
+ {
+ return checked_guard(m_client, &IClientWrapper::findKeepAliveResource, host, resultCallback);
+ }
+ OCStackResult OCPlatform_impl::sendKeepAliveRequest(std::string host, const OCRepresentation& rep,
+ KeepAliveCallback resultCallback)
+ {
+ return checked_guard(m_client, &IClientWrapper::sendKeepAliveRequest, host,
+ rep, resultCallback);
+ }
+#endif
OCStackResult OCPlatform_impl::getDeviceId(OCUUIdentity *myUuid)
{
return OCGetDeviceId(myUuid);