* Initialize the connectivity abstraction module.
* It will initialize adapters, thread pool and other modules based on the platform
* compilation options.
- *
+ * @param[in] transportType transport type to initialize.
* @return ::CA_STATUS_OK or ::CA_STATUS_FAILED or ::CA_MEMORY_ALLOC_FAILED
*/
-CAResult_t CAInitialize();
+CAResult_t CAInitialize(CATransportAdapter_t transportType);
/**
* Terminate the connectivity abstraction module.
* Initializes different adapters based on the compilation flags.
* @param[in] handle thread pool handle created by message handler
* for different adapters.
+ * @param[in] transportType transport type to initialize.
*/
-void CAInitializeAdapters(ca_thread_pool_t handle);
+void CAInitializeAdapters(ca_thread_pool_t handle, CATransportAdapter_t transportType);
#endif
/**
/**
* Initialize the message handler by starting thread pool and initializing the
* send and receive queue.
+ * @param[in] transportType transport type to initialize.
* @return ::CA_STATUS_OK or ERROR CODES (::CAResult_t error codes in cacommon.h).
*/
-CAResult_t CAInitializeMessageHandler();
+CAResult_t CAInitializeMessageHandler(CATransportAdapter_t transportType);
/**
* Terminate the message handler by stopping the thread pool and destroying the queues.
#endif // __WITH_DTLS__ or __WITH_TLS__
-CAResult_t CAInitialize()
+CAResult_t CAInitialize(CATransportAdapter_t transportType)
{
OIC_LOG_V(DEBUG, TAG, "IoTivity version is v%s", IOTIVITY_VERSION);
- OIC_LOG(DEBUG, TAG, "CAInitialize");
+ OIC_LOG_V(DEBUG, TAG, "CAInitialize type : %d", transportType);
if (!g_isInitialized)
{
- CAResult_t res = CAInitializeMessageHandler();
+ CAResult_t res = CAInitializeMessageHandler(transportType);
if (res != CA_STATUS_OK)
{
OIC_LOG(ERROR, TAG, "CAInitialize has failed");
}
}
-void CAInitializeAdapters(ca_thread_pool_t handle)
+void CAInitializeAdapters(ca_thread_pool_t handle, CATransportAdapter_t transportType)
{
- OIC_LOG(DEBUG, TAG, "initialize adapters..");
+ OIC_LOG_V(DEBUG, TAG, "initialize adapters %d", transportType);
// Initialize adapters and register callback.
#ifdef IP_ADAPTER
- CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_IP) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType & CA_ALL_ADAPTERS))
+ {
+ CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAAdapterErrorHandleCallback, handle);
+ }
#endif /* IP_ADAPTER */
#ifdef EDR_ADAPTER
- CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_RFCOMM_BTEDR) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* EDR_ADAPTER */
#ifdef LE_ADAPTER
- CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_GATT_BTLE) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* LE_ADAPTER */
#ifdef RA_ADAPTER
- CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- handle);
+ if ((transportType & CA_ADAPTER_REMOTE_ACCESS) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ handle);
+ }
#endif /* RA_ADAPTER */
#ifdef TCP_ADAPTER
- CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_TCP) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* TCP_ADAPTER */
#ifdef NFC_ADAPTER
- CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_NFC) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAAdapterErrorHandleCallback, handle);
+ }
#endif /* NFC_ADAPTER */
}
g_nwMonitorHandler = nwMonitorHandler;
}
-CAResult_t CAInitializeMessageHandler()
+CAResult_t CAInitializeMessageHandler(CATransportAdapter_t transportType)
{
CASetPacketReceivedCallback(CAReceivedPacketCallback);
CASetErrorHandleCallback(CAErrorHandler);
}
// initialize interface adapters by controller
- CAInitializeAdapters(g_threadPoolHandle);
+ CAInitializeAdapters(g_threadPoolHandle, transportType);
#else
// retransmission initialize
CAResult_t res = CARetransmissionInitialize(&g_retransmissionContext, NULL, CASendUnicastData,
protected:
virtual void SetUp()
{
- CAInitialize();
+ CAInitialize(CA_DEFAULT_ADAPTER);
}
virtual void TearDown()
// CAInitialize TC
TEST(InitializeTest, CAInitializeTest)
{
- EXPECT_EQ(CA_STATUS_OK, CAInitialize());
+ EXPECT_EQ(CA_STATUS_OK, CAInitialize(CA_DEFAULT_ADAPTER));
CATerminate();
}
char* check = (char *) "terminate success";
EXPECT_STREQ(check, "terminate success");
- CAInitialize();
+ CAInitialize(CA_DEFAULT_ADAPTER);
}
// CAStartListeningServer TC
protected:
virtual void SetUp()
{
- CAInitialize();
+ CAInitialize(CA_ADAPTER_IP);
}
virtual void TearDown()
OCGetSupportedEndpointTpsFlags
OCInit
OCInit1
+OCInit2
OCNotifyAllObservers
OCNotifyListOfObservers
OCPayloadDestroy
/**
* This function Initializes the OC Stack. Must be called prior to starting the stack.
*
+ * @param mode OCMode Host device is client, server, or client-server.
+ * @param serverFlags OCTransportFlags Default server transport flags.
+ * @param clientFlags OCTransportFlags Default client transport flags.
+ * @param transportType OCTransportAdapter value to initialize.
+ *
+ * @return ::OC_STACK_OK on success, some other value upon failure.
+ */
+OCStackResult OCInit2(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags,
+ OCTransportAdapter transportType);
+
+/**
+ * This function Initializes the OC Stack. Must be called prior to starting the stack.
+ *
* @param ipAddr IP Address of host device. Deprecated parameter.
* @param port Port of host device. Deprecated parameter.
* @param mode OCMode Host device is client, server, or client-server.
*
* Note: At least one interface must succeed to initialize. If all calls to @ref CASelectNetwork
* return something other than @ref CA_STATUS_OK, then this function fails.
- *
+ * @param transportType OCTransportAdapter value to select.
* @return ::CA_STATUS_OK on success, some other value upon failure.
*/
-static CAResult_t OCSelectNetwork();
+static CAResult_t OCSelectNetwork(OCTransportAdapter transportType);
/**
* Convert CAResponseResult_t to OCStackResult.
OCStackResult OCInit1(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags)
{
+ OIC_LOG(DEBUG, TAG, "call OCInit1");
+ return OCInit2(mode, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS, OC_DEFAULT_ADAPTER);
+}
+
+OCStackResult OCInit2(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags,
+ OCTransportAdapter transportType)
+{
if(stackState == OC_STACK_INITIALIZED)
{
OIC_LOG(INFO, TAG, "Subsequent calls to OCInit() without calling \
result = InitializeScheduleResourceList();
VERIFY_SUCCESS(result, OC_STACK_OK);
- result = CAResultToOCResult(CAInitialize());
+ result = CAResultToOCResult(CAInitialize((CATransportAdapter_t)transportType));
VERIFY_SUCCESS(result, OC_STACK_OK);
- result = CAResultToOCResult(OCSelectNetwork());
+ result = CAResultToOCResult(OCSelectNetwork(transportType));
VERIFY_SUCCESS(result, OC_STACK_OK);
result = CAResultToOCResult(CARegisterNetworkMonitorHandler(
return sidStr;
}
-CAResult_t OCSelectNetwork()
+CAResult_t OCSelectNetwork(OCTransportAdapter transportType)
{
+ OIC_LOG_V(DEBUG, TAG, "OCSelectNetwork [%d]", transportType);
CAResult_t retResult = CA_STATUS_FAILED;
CAResult_t caResult = CA_STATUS_OK;
// If CA status is not initialized, CASelectNetwork() will not be called.
if (caResult != CA_STATUS_NOT_INITIALIZED)
{
- caResult = CASelectNetwork(connTypes[i]);
- if (caResult == CA_STATUS_OK)
- {
- retResult = CA_STATUS_OK;
- }
+ if ((connTypes[i] & transportType) || (OC_DEFAULT_ADAPTER == transportType))
+ {
+ OIC_LOG_V(DEBUG, TAG, "call CASelectNetwork [%d]", connTypes[i]);
+ caResult = CASelectNetwork(connTypes[i]);
+ if (caResult == CA_STATUS_OK)
+ {
+ retResult = CA_STATUS_OK;
+ }
+ }
+ else
+ {
+ OIC_LOG_V(DEBUG, TAG, "there is no transport type [%d]", connTypes[i]);
+ }
}
}
PlatformConfig cfg {
OC::ServiceType::InProc,
OC::ModeType::Both,
- "0.0.0.0",
- 0,
+ OCConnectivityType::CT_ADAPTER_IP,
+ OCConnectivityType::CT_ADAPTER_IP,
+ (OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP|OCTransportAdapter::OC_ADAPTER_TCP),
OC::QualityOfService::HighQos,
&ps
};
PlatformConfig cfg {
OC::ServiceType::InProc,
OC::ModeType::Server,
- "0.0.0.0", // By setting to "0.0.0.0", it binds to all available interfaces
- 0, // Uses randomly available port
+ (OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP|OCTransportAdapter::OC_ADAPTER_TCP),
OC::QualityOfService::LowQos,
&ps
};
/** default flags for client. */
OCConnectivityType clientConnectivity;
+ /** transport type to initialize. */
+ OCTransportAdapter transportType;
+
/** not used. */
std::string ipAddress;
mode(ModeType::Both),
serverConnectivity(CT_DEFAULT),
clientConnectivity(CT_DEFAULT),
+ transportType(OC_DEFAULT_ADAPTER),
ipAddress("0.0.0.0"),
port(0),
QoS(QualityOfService::NaQos),
mode(mode_),
serverConnectivity(serverConnectivity_),
clientConnectivity(clientConnectivity_),
+ transportType(OC_DEFAULT_ADAPTER),
ipAddress(""),
port(0),
QoS(QoS_),
mode(mode_),
serverConnectivity(CT_DEFAULT),
clientConnectivity(CT_DEFAULT),
+ transportType(OC_DEFAULT_ADAPTER),
ipAddress(ipAddress_),
port(port_),
QoS(QoS_),
ps(ps_)
{}
+ PlatformConfig(const ServiceType serviceType_,
+ const ModeType mode_,
+ OCTransportAdapter transportType_,
+ const QualityOfService QoS_,
+ OCPersistentStorage *ps_ = nullptr)
+ : serviceType(serviceType_),
+ mode(mode_),
+ serverConnectivity(CT_DEFAULT),
+ clientConnectivity(CT_DEFAULT),
+ transportType(transportType_),
+ ipAddress(""),
+ port(0),
+ QoS(QoS_),
+ ps(ps_)
+ {}
+ PlatformConfig(const ServiceType serviceType_,
+ const ModeType mode_,
+ OCConnectivityType serverConnectivity_,
+ OCConnectivityType clientConnectivity_,
+ OCTransportAdapter transportType_,
+ const QualityOfService QoS_,
+ OCPersistentStorage *ps_ = nullptr)
+ : serviceType(serviceType_),
+ mode(mode_),
+ serverConnectivity(serverConnectivity_),
+ clientConnectivity(clientConnectivity_),
+ transportType(transportType_),
+ ipAddress(""),
+ port(0),
+ QoS(QoS_),
+ ps(ps_)
+ {}
+
};
enum RequestHandlerFlag
OCStackResult InProcClientWrapper::start()
{
- OIC_LOG(INFO, TAG, "start ocplatform");
+ OIC_LOG_V(INFO, TAG, "start ocplatform for client : %d", m_cfg.transportType);
+
if (m_cfg.mode == ModeType::Client)
{
OCTransportFlags serverFlags =
static_cast<OCTransportFlags>(m_cfg.serverConnectivity & CT_MASK_FLAGS);
OCTransportFlags clientFlags =
static_cast<OCTransportFlags>(m_cfg.clientConnectivity & CT_MASK_FLAGS);
- OCStackResult result = OCInit1(OC_CLIENT, serverFlags, clientFlags);
+ OCStackResult result = OCInit2(OC_CLIENT, serverFlags, clientFlags,
+ m_cfg.transportType);
if (OC_STACK_OK != result)
{
OCStackResult InProcServerWrapper::start()
{
- OIC_LOG(INFO, TAG, "start");
+ OIC_LOG_V(INFO, TAG, "start ocplatform for server : %d", m_cfg.transportType);
OCMode initType;
-
if(m_cfg.mode == ModeType::Server)
{
initType = OC_SERVER;
static_cast<OCTransportFlags>(m_cfg.serverConnectivity & CT_MASK_FLAGS);
OCTransportFlags clientFlags =
static_cast<OCTransportFlags>(m_cfg.clientConnectivity & CT_MASK_FLAGS);
- OCStackResult result = OCInit1(initType, serverFlags, clientFlags);
+ OCStackResult result = OCInit2(initType, serverFlags, clientFlags,
+ m_cfg.transportType);
if(OC_STACK_OK != result)
{