* @var gEnrolleeStatusCb
* @brief Fucntion pointer holding the callback for intimation of EasySetup Enrollee status callback
*/
-static EventCallback gEnrolleeStatusCb = NULL;
+static ESEnrolleeEventCallback gEnrolleeStatusCb = NULL;
/**
* @var gIsSecured
//-----------------------------------------------------------------------------
// Private internal function prototypes
//-----------------------------------------------------------------------------
-void OnboardingCallback(ESResult esResult);
-void ProvisioningCallback(ESResult esResult);
-void OnboardingCallbackTargetNet(ESResult esResult);
-static bool ValidateParam(OCConnectivityType networkType, const char *ssid, const char *passwd,
- EventCallback cb);
+void ESOnboardingCallback(ESResult esResult);
+void ESProvisioningCallback(ESResult esResult);
+void ESOnboardingCallbackTargetNet(ESResult esResult);
+static bool ESEnrolleeValidateParam(OCConnectivityType networkType, const char *ssid,
+ const char *passwd, ESEnrolleeEventCallback cb);
-void OnboardingCallback(ESResult esResult)
+void ESOnboardingCallback(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "OnboardingCallback with result = %d", esResult);
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESOnboardingCallback with result = %d", esResult);
if(esResult == ES_OK)
{
gEnrolleeStatusCb(esResult, ES_ON_BOARDED_STATE);
}
}
-void ProvisioningCallback(ESResult esResult)
+void ESProvisioningCallback(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ProvisioningCallback with result = %d", esResult);
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESProvisioningCallback with result = %d", esResult);
if (esResult == ES_RECVTRIGGEROFPROVRES)
{
OIC_LOG(DEBUG, ES_ENROLLEE_TAG, "Connecting with target network");
// Connecting/onboarding to target network
- ConnectToWiFiNetwork(gTargetSsid, gTargetPass, OnboardingCallbackTargetNet);
+ ConnectToWiFiNetwork(gTargetSsid, gTargetPass, ESOnboardingCallbackTargetNet);
}
else
{
}
}
-void OnboardingCallbackTargetNet(ESResult esResult)
+void ESOnboardingCallbackTargetNet(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "OnboardingCallback on target network with result = %d",
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESOnboardingCallback on target network with result = %d",
esResult);
if(esResult == ES_OK)
{
}
}
-ESResult InitEasySetup(OCConnectivityType networkType, const char *ssid, const char *passwd,
+ESResult ESInitEnrollee(OCConnectivityType networkType, const char *ssid, const char *passwd,
bool isSecured,
- EventCallback cb)
+ ESEnrolleeEventCallback cb)
{
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup IN");
- if(!ValidateParam(networkType,ssid,passwd,cb))
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitEnrollee IN");
+ if(!ESEnrolleeValidateParam(networkType,ssid,passwd,cb))
{
OIC_LOG(ERROR, ES_ENROLLEE_TAG,
- "InitEasySetup::Stopping Easy setup due to invalid parameters");
+ "ESInitEnrollee::Stopping Easy setup due to invalid parameters");
return ES_ERROR;
}
OIC_LOG(INFO, ES_ENROLLEE_TAG, "received callback");
OIC_LOG(INFO, ES_ENROLLEE_TAG, "onboarding now..");
- if(!ESOnboard(ssid, passwd, OnboardingCallback))
+ if(!ESOnboard(ssid, passwd, ESOnboardingCallback))
{
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "InitEasySetup::On-boarding failed");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESInitEnrollee::On-boarding failed");
cb(ES_ERROR, ES_INIT_STATE);
return ES_ERROR;
}
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup OUT");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitEnrollee OUT");
return ES_OK;
}
-ESResult TerminateEasySetup()
+ESResult ESTerminateEnrollee()
{
UnRegisterResourceEventCallBack();
return ES_ERROR;
}
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "TerminateEasySetup success");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESTerminateEnrollee success");
return ES_OK;
}
-ESResult InitProvisioning()
+ESResult ESInitProvisioning()
{
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitProvisioning <<IN>>");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitProvisioning <<IN>>");
if (CreateProvisioningResource(gIsSecured) != OC_STACK_OK)
{
return ES_ERROR;
}
- RegisterResourceEventCallBack(ProvisioningCallback);
+ RegisterResourceEventCallBack(ESProvisioningCallback);
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitProvisioning OUT");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitProvisioning <<OUT>>");
return ES_RESOURCECREATED;
}
-static bool ValidateParam(OCConnectivityType /*networkType*/, const char *ssid, const char *passwd,
- EventCallback cb)
+static bool ESEnrolleeValidateParam(OCConnectivityType /*networkType*/, const char *ssid,
+ const char *passwd, ESEnrolleeEventCallback cb)
{
if (!ssid || !passwd || !cb)
{
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ValidateParam - Invalid parameters");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESEnrolleeValidateParam - Invalid parameters");
return false;
}
return true;
/**
* It will do onboarding based on the user's configuration.
*/
-bool ESOnboard(const char * ssid, const char* passwd, NetworkEventCallback cb)
+bool ESOnboard(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb)
{
OIC_LOG(DEBUG, ES_ENROLLEE_TAG, "ESOnboard IN");
OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
OCRepPayload* constructResponse(OCEntityHandlerRequest *ehRequest);
-ResourceEventCallback gNetworkInfoProvEventCb = NULL;
+ESEnrolleeResourceEventCallback gNetworkInfoProvEventCb = NULL;
-void RegisterResourceEventCallBack(ResourceEventCallback cb)
+void RegisterResourceEventCallBack(ESEnrolleeResourceEventCallback cb)
{
gNetworkInfoProvEventCb = cb;
}
void ESCreateSoftapCallback(int result, const char *ip, const char* mac_addr,
const char* device_name );
-NetworkEventCallback gCallback;
+ESEnrolleeNetworkEventCallback gCallback;
/**
* It will return Device which is creating Soft AP.
/**
* This API will create the softap at enrollee
*/
-void ESCreateSoftap(const char * ssid, const char* passwd, NetworkEventCallback cb)
+void ESCreateSoftap(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb)
{
gCallback = cb;
/**
* @var g_retryCounter
- * @brief Retry counter for cancelling network retry. Currently network retry is limited to 5 attempts
+ * @brief Retry counter for cancelling network retry. Currently network retry is
+ * limited to 5 attempts
*/
static uint16_t g_retryCounter = 0;
// this server will NOT be listening on 224.0.1.187 multicast address.
static const char ARDUINO_WIFI_SHIELD_UDP_FW_VER[] = "1.1.0";
-ESResult ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback cb)
+ESResult ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback cb)
{
char *fwVersion;
int status = WL_IDLE_STATUS;
*
* @param esResult ESResult provides the current state of the network connection status
*/
-typedef void (*NetworkEventCallback)(ESResult esResult);
+typedef void (*ESEnrolleeNetworkEventCallback)(ESResult esResult);
typedef struct
{
byte mac[6];
} NetworkInfo;
-ESResult ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback);
+ESResult ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback);
ESResult getCurrentNetworkInfo(OCConnectivityType targetType, NetworkInfo *info);
#endif
#endif // __cplusplus
/*
- * Callback function for updating the Enrollee OnBoarding and Provisioning status result to the application
+ * Callback function for updating the Enrollee OnBoarding and Provisioning status result
+ * to the application
*
* @param esResult ESResult provides the current state of the Enrollee Device
*/
-typedef void (*EventCallback)(ESResult esResult, EnrolleeState enrolleeState);
+typedef void (*ESEnrolleeEventCallback)(ESResult esResult, ESEnrolleeState enrolleeState);
/**
* This function Initializes the EasySetup. This API must be called prior to invoking any other API
*
* @param networkType NetworkType on which OnBoarding has to be performed.
* @param ssid SSID of the target SoftAP network to which the Enrollee is connecting.
- * @param passwd Password of the target SoftAP network to which the Enrollee is connecting
+ * @param passwd Password of the target SoftAP network to which the Enrollee is
+ * connecting
* @param isSecured True if the Enrollee is operating in secured mode.
- * @param eventCallback EventCallback for for updating the Enrollee OnBoarding status result to
- * the application
+ * @param eventCallback ESEnrolleeEventCallback for for updating the Enrollee OnBoarding status
+ * result to the application
* @return ::ES_OK on success, some other value upon failure.
*/
-ESResult InitEasySetup(OCConnectivityType networkType, const char *ssid, const char *passwd,
- bool isSecured,
- EventCallback eventCallback);
+ESResult ESInitEnrollee(OCConnectivityType networkType, const char *ssid, const char *passwd,
+ bool isSecured, ESEnrolleeEventCallback eventCallback);
/**
* This function performs initialization of Provisioning and Network resources needed for EasySetup
* process.
* @return ::ES_OK on success, some other value upon failure.
*/
-ESResult InitProvisioning();
+ESResult ESInitProvisioning();
/**
* This function performs termination of Provisioning and Network resources.
*
* @return ::ES_OK on success, some other value upon failure.
*/
-ESResult TerminateEasySetup();
+ESResult ESTerminateEnrollee();
#ifdef __cplusplus
}
const char *gSsid = "DLNA_LISMORE1";
const char *gPass = "dlna@010203";
char *gIpAddress;
-NetworkEventCallback gNetworkEventCb;
+ESEnrolleeNetworkEventCallback gNetworkEventCb;
/*
* All the functions defined in this file are stub functions to be implemented by the end user of
ESActivateWifi();
}
-void ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback cb)
+void ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback cb)
{
OIC_LOG_V(INFO, LOG_TAG, "ConnectToWiFiNetwork %s %s",ssid,pass);
gPass = pass;
*
* @param esResult ESResult provides the current state of the network connection status
*/
-typedef void (*NetworkEventCallback)(ESResult esResult);
+typedef void (*ESEnrolleeNetworkEventCallback)(ESResult esResult);
typedef struct
{
//byte mac[6];
} NetworkInfo;
-void ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback);
+void ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback);
ESResult getCurrentNetworkInfo(OCConnectivityType targetType, NetworkInfo *info);
#endif
* @var gEnrolleeStatusCb
* @brief Fucntion pointer holding the callback for intimation of EasySetup Enrollee status callback
*/
-static EventCallback gEnrolleeStatusCb = NULL;
+static ESEnrolleeEventCallback gEnrolleeStatusCb = NULL;
/**
* @var gIsSecured
*/
static bool gIsSecured = false;
-void OnboardingCallback(ESResult esResult)
+void ESOnboardingCallback(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "OnboardingCallback with result = %d", esResult);
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESOnboardingCallback with result = %d", esResult);
if(esResult == ES_OK)
{
gEnrolleeStatusCb(esResult, ES_ON_BOARDED_STATE);
}
}
-void ProvisioningCallback(ESResult esResult)
+void ESProvisioningCallback(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ProvisioningCallback with result = %d", esResult);
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESProvisioningCallback with result = %d", esResult);
if (esResult == ES_RECVTRIGGEROFPROVRES)
{
OIC_LOG(DEBUG, ES_ENROLLEE_TAG, "Connecting with target network");
// Connecting/onboarding to target network
- ConnectToWiFiNetwork(gTargetSsid, gTargetPass, OnboardingCallbackTargetNet);
+ ConnectToWiFiNetwork(gTargetSsid, gTargetPass, ESOnboardingCallbackTargetNet);
}
else
{
}
}
-void OnboardingCallbackTargetNet(ESResult esResult)
+void ESOnboardingCallbackTargetNet(ESResult esResult)
{
- OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "OnboardingCallback on target network with result = %d",
+ OIC_LOG_V(DEBUG, ES_ENROLLEE_TAG, "ESOnboardingCallback on target network with result = %d",
esResult);
if(esResult == ES_OK)
{
}
}
-ESResult InitEasySetup(OCConnectivityType networkType, const char *ssid, const char *passwd,
+ESResult ESInitEnrollee(OCConnectivityType networkType, const char *ssid, const char *passwd,
bool isSecured,
- EventCallback cb)
+ ESEnrolleeEventCallback cb)
{
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup IN");
- if(!ValidateParam(networkType,ssid,passwd,cb))
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitEnrollee IN");
+ if(!ESEnrolleeValidateParam(networkType,ssid,passwd,cb))
{
OIC_LOG(ERROR, ES_ENROLLEE_TAG,
- "InitEasySetup::Stopping Easy setup due to invalid parameters");
+ "ESInitEnrollee::Stopping Easy setup due to invalid parameters");
return ES_ERROR;
}
OIC_LOG(INFO, ES_ENROLLEE_TAG, "received callback");
OIC_LOG(INFO, ES_ENROLLEE_TAG, "onboarding now..");
- if(!ESOnboard(ssid, passwd, OnboardingCallback))
+ if(!ESOnboard(ssid, passwd, ESOnboardingCallback))
{
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "InitEasySetup::On-boarding failed");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESInitEnrollee::On-boarding failed");
cb(ES_ERROR, ES_INIT_STATE);
return ES_ERROR;
}
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup OUT");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitEnrollee OUT");
return ES_OK;
}
-ESResult TerminateEasySetup()
+ESResult ESTerminateEnrollee()
{
UnRegisterResourceEventCallBack();
return ES_ERROR;
}
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "TerminateEasySetup success");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESTerminateEnrollee success");
return ES_OK;
}
-ESResult InitProvisioning()
+ESResult ESInitProvisioning()
{
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitProvisioning <<IN>>");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitProvisioning <<IN>>");
if (CreateProvisioningResource(gIsSecured) != OC_STACK_OK)
{
return ES_ERROR;
}
- RegisterResourceEventCallBack(ProvisioningCallback);
+ RegisterResourceEventCallBack(ESProvisioningCallback);
- OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitProvisioning OUT");
+ OIC_LOG(INFO, ES_ENROLLEE_TAG, "ESInitProvisioning <<OUT>>");
return ES_RESOURCECREATED;
}
-static bool ValidateParam(OCConnectivityType networkType, const char *ssid, const char *passwd,
- EventCallback cb)
+static bool ESEnrolleeValidateParam(OCConnectivityType networkType, const char *ssid,
+ const char *passwd, ESEnrolleeEventCallback cb)
{
if (!ssid || !passwd || !cb)
{
- OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ValidateParam - Invalid parameters");
+ OIC_LOG(ERROR, ES_ENROLLEE_TAG, "ESEnrolleeValidateParam - Invalid parameters");
return false;
}
return true;
// Private internal callback function prototypes for Easy setup [Enrollee]
//-----------------------------------------------------------------------------
- /*
+ /*
* Callback for on boarding
*/
-void OnboardingCallback(ESResult esResult);
+void ESOnboardingCallback(ESResult esResult);
- /*
+ /*
* Callback for provisioning
*/
-void ProvisioningCallback(ESResult SSSS);
+void ESProvisioningCallback(ESResult SSSS);
- /*
+ /*
* Callback for on boarding target Network
*/
-void OnboardingCallbackTargetNet(ESResult esResult);
+void ESOnboardingCallbackTargetNet(ESResult esResult);
- /*
- * Function for validating the parameter for InitEasySetup API
+ /*
+ * Function for validating the parameter for ESInitEnrollee API
*/
-static bool ValidateParam(OCConnectivityType networkType, const char *ssid, const char *passwd,
- EventCallback cb);
+static bool ESEnrolleeValidateParam(OCConnectivityType networkType, const char *ssid,
+ const char *passwd, ESEnrolleeEventCallback cb);
#ifdef __cplusplus
}
/**
* It will do onboarding based on the user's configuration.
*/
-bool ESOnboard(const char * ssid, const char* passwd, NetworkEventCallback cb)
+bool ESOnboard(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb)
{
OIC_LOG(DEBUG, ES_ENROLLEE_TAG, "ESOnboard IN");
* @file
*
* This file contains APIs to on-board ( connect ) Enrollee device into Ad-hoc network
- * @Note : Some of the APIs of this file need to be modified by the OEM according to the device configuration
+ * @Note : Some of the APIs of this file need to be modified by the OEM according to the
+ * device configuration
*/
/**
* This function on-board Enrollee device onto ad-hoc network.
- * @param ssid SSID of the target SoftAP network to which the Enrollee is connecting.
- * @param passwd Password of the target SoftAP network to which the Enrollee is connecting.
- * @param NetworkEventCallback Callback function for result update
+ * @param ssid SSID of the target SoftAP network to which the Enrollee
+ * is connecting.
+ * @param passwd Password of the target SoftAP network to which the
+ * Enrollee is connecting.
+ * @param ESEnrolleeNetworkEventCallback Callback function for result update
* @return ::True, if on-boarding is successful.
*/
-bool ESOnboard(const char * ssid, const char* passwd, NetworkEventCallback cb);
+bool ESOnboard(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb);
/**
* This function verify if the on-boarding is through SoftAP.
OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
OCRepPayload* constructResponse(OCEntityHandlerRequest *ehRequest);
-ResourceEventCallback gNetworkInfoProvEventCb = NULL;
+ESEnrolleeResourceEventCallback gNetworkInfoProvEventCb = NULL;
-void RegisterResourceEventCallBack(ResourceEventCallback cb)
+void RegisterResourceEventCallBack(ESEnrolleeResourceEventCallback cb)
{
gNetworkInfoProvEventCb = cb;
}
extern "C" {
#endif
-typedef void (*ResourceEventCallback)(ESResult);
+typedef void (*ESEnrolleeResourceEventCallback)(ESResult);
/* Structure to represent a Light resource */
typedef struct PROVRESOURCE
OCStackResult DeleteProvisioningResource();
void GetTargetNetworkInfoFromProvResource(char *, char *);
-void RegisterResourceEventCallBack(ResourceEventCallback);
+void RegisterResourceEventCallBack(ESEnrolleeResourceEventCallback);
void UnRegisterResourceEventCallBack(void);
#ifdef __cplusplus
void ESCreateSoftapCallback(int result, const char *ip, const char* mac_addr,
const char* device_name );
-NetworkEventCallback gCallback;
+ESEnrolleeNetworkEventCallback gCallback;
/**
* It will return Device which is creating Soft AP.
/**
* This API will create the softap at enrollee
*/
-void ESCreateSoftap(const char * ssid, const char* passwd, NetworkEventCallback cb)
+void ESCreateSoftap(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb)
{
gCallback = cb;
* @file
*
* This file contains platform agnostic API for creation of Soft AP
- * @Note : Some of the APIs of this file need to be modified by the OEM according to the device configuration
+ * @Note : Some of the APIs of this file need to be modified by the OEM according to the device
+ * configuration
*/
/**
/**
* This function Initializes the EasySetup. This API must be called prior to invoking any other API
*
- * @param ssid SSID of the target SoftAP network to which the Enrollee is connecting.
- * @param passwd Password of the target SoftAP network to which the Enrollee is connecting
- * @param NetworkEventCallback Callback function for result update
+ * @param ssid SSID of the target SoftAP network to which the Enrollee is
+ * connecting.
+ * @param passwd Password of the target SoftAP network to which the Enrollee is
+ * connecting
+ * @param ESEnrolleeNetworkEventCallback Callback function for result update
* @return ::void.
*/
-void ESCreateSoftap(const char * ssid, const char* passwd, NetworkEventCallback cb);
+void ESCreateSoftap(const char * ssid, const char* passwd, ESEnrolleeNetworkEventCallback cb);
#ifdef __cplusplus
const char *gPass = "dlna@010203";
char *gIpAddress = NULL;
wifi_ap_h connectedWifi;
-NetworkEventCallback gNetworkEventCb;
+ESEnrolleeNetworkEventCallback gNetworkEventCb;
static void ESActivateWifi();
static const char*
ESActivateWifi();
}
-void ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback cb)
+void ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback cb)
{
OIC_LOG_V(INFO, LOG_TAG, "ConnectToWiFiNetwork %s %s",ssid,pass);
gPass = pass;
*
* @param esResult ESResult provides the current state of the network connection status
*/
-typedef void (*NetworkEventCallback)(ESResult esResult);
+typedef void (*ESEnrolleeNetworkEventCallback)(ESResult esResult);
typedef struct
{
//byte mac[6];
} NetworkInfo;
-void ConnectToWiFiNetwork(const char *ssid, const char *pass, NetworkEventCallback);
+void ConnectToWiFiNetwork(const char *ssid, const char *pass,
+ ESEnrolleeNetworkEventCallback);
ESResult getCurrentNetworkInfo(OCConnectivityType targetType, NetworkInfo *info);
#endif
* This API creats the Soft AP using the platform specific native system calls.
* @Note This API to be implemented by the OEM if Enrollee device SoC supports SoftAP
*
- * @param networkType NetworkType on which OnBoarding has to be performed.
- * @param ssid SSID of the target SoftAP network to which the Enrollee is connecting.
- * @param passwd Password of the target SoftAP network to which the Enrollee is connecting
- * @param SoftAPCallbackNative EventCallback for for updating the Enrollee OnBoarding status result to the application
+ * @param networkType NetworkType on which OnBoarding has to be performed.
+ * @param ssid SSID of the target SoftAP network to which the Enrollee is
+ * connecting.
+ * @param passwd Password of the target SoftAP network to which the Enrollee is
+ * connecting
+ * @param SoftAPCallbackNative EventCallback for for updating the Enrollee OnBoarding status
+ * result to the application
*/
void ESCreateSoftapNative(const char * ssid, const char* passwd, SoftAPCallbackNative cb);
// Callback functions
//-----------------------------------------------------------------------------
extern "C" void EventCallbackInApplication(ESResult esResult,
- EnrolleeState enrolleeState)
+ ESEnrolleeState enrolleeState)
{
OIC_LOG(INFO, TAG, "Entering EventCallbackInApplication");
{
OIC_LOG(INFO, TAG, "Entering InitESEnrollee");
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
"EasySetup123",
"EasySetup123",
0,
TEST(ESEnrolleeInit, ESEnrolleeInitNullSSID)
{
- EXPECT_EQ(ES_ERROR, InitEasySetup(CT_ADAPTER_IP, 0, passwd, 0, EventCallbackInApplication));
+ EXPECT_EQ(ES_ERROR, ESInitEnrollee(CT_ADAPTER_IP, 0, passwd, 0, EventCallbackInApplication));
}
TEST(ESEnrolleeInit, ESEnrolleeInitNullPassword)
{
- EXPECT_EQ(ES_ERROR, InitEasySetup(CT_ADAPTER_IP, ssid, 0, 0, EventCallbackInApplication));
+ EXPECT_EQ(ES_ERROR, ESInitEnrollee(CT_ADAPTER_IP, ssid, 0, 0, EventCallbackInApplication));
}
TEST(ESEnrolleeInit, ESEnrolleeInitNullCb)
{
- EXPECT_EQ(ES_ERROR, InitEasySetup(CT_ADAPTER_IP, ssid, passwd, 0, 0));
+ EXPECT_EQ(ES_ERROR, ESInitEnrollee(CT_ADAPTER_IP, ssid, passwd, 0, 0));
}
-TEST(ESEnrolleeInit, ESEnrolleeInitEasySetupSuccess)
+TEST(ESEnrolleeInit, ESEnrolleeESInitEnrolleeSuccess)
{
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
ssid,
passwd,
0,
EXPECT_EQ(OC_STACK_ERROR, OCStop());
}
-TEST(ESProvisioning, ESInitProvisioning)
+TEST(ESProvisioning, ESInitProvisioningResource)
{
- EXPECT_EQ(ES_RESOURCECREATED, InitProvisioning());
+ EXPECT_EQ(ES_RESOURCECREATED, ESInitProvisioning());
}
TEST(ESProvisioning, ESInitProvisioningWithOCStackClientMode)
{
EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, OC_CLIENT));
- EXPECT_EQ(ES_ERROR, InitProvisioning());
+ EXPECT_EQ(ES_ERROR, ESInitProvisioning());
EXPECT_EQ(OC_STACK_OK, OCStop());
}
TEST(ESOnboarding, ESOnboardingSoftAp)
{
- EXPECT_EQ(1, ESOnboard(ssid, passwd, OnboardingCallback));
+ EXPECT_EQ(1, ESOnboard(ssid, passwd, ESOnboardingCallback));
}
TEST(ESOnboarding, ESOnboardingSoftApEnrollee)
TEST(ESStop, ESTerminateEasysetupWithoutESInit)
{
- EXPECT_EQ(ES_ERROR, TerminateEasySetup());
+ EXPECT_EQ(ES_ERROR, ESTerminateEnrollee());
}
TEST(ESStop, ESTerminateEasysetupWithoutOCStack)
{
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
ssid,
passwd,
0,
EventCallbackInApplication));
- EXPECT_EQ(ES_ERROR, TerminateEasySetup());
+ EXPECT_EQ(ES_ERROR, ESTerminateEnrollee());
}
TEST(ESStop, ESTerminateEasysetupWithOutCreateProvisioningResource)
{
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
ssid,
passwd,
0,
EventCallbackInApplication));
EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
- EXPECT_EQ(ES_ERROR, TerminateEasySetup());
+ EXPECT_EQ(ES_ERROR, ESTerminateEnrollee());
EXPECT_EQ(OC_STACK_OK, OCStop());
}
TEST(ESStop, ESTerminateEasysetupWithoutProviosioningResource)
{
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
ssid,
passwd,
0,
EventCallbackInApplication));
EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, OC_SERVER));
- EXPECT_EQ(ES_ERROR, TerminateEasySetup());
+ EXPECT_EQ(ES_ERROR, ESTerminateEnrollee());
EXPECT_EQ(OC_STACK_OK, OCStop());
}
TEST(ESStop, ESTerminateEasysetupSuccess)
{
- EXPECT_EQ(ES_OK, InitEasySetup(CT_ADAPTER_IP,
+ EXPECT_EQ(ES_OK, ESInitEnrollee(CT_ADAPTER_IP,
ssid,
passwd,
0,
EventCallbackInApplication));
EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, OC_SERVER));
- EXPECT_EQ(ES_RESOURCECREATED, InitProvisioning());
- EXPECT_EQ(ES_OK, TerminateEasySetup());
+ EXPECT_EQ(ES_RESOURCECREATED, ESInitProvisioning());
+ EXPECT_EQ(ES_OK, ESTerminateEnrollee());
EXPECT_EQ(OC_STACK_OK, OCStop());
}
* Enrollee moves to this state after connecting to target network
*/
ES_ON_BOARDED_TARGET_NETWORK_STATE,
-}EnrolleeState;
+}ESEnrolleeState;
/**
* Provisioning Device Status
Serial.println("============");
}
-void EventCallbackInApp(ESResult esResult, EnrolleeState enrolleeState)
+void EventCallbackInApp(ESResult esResult, ESEnrolleeState enrolleeState)
{
Serial.println("callback!!! in app");
{
OIC_LOG(DEBUG, TAG, "OCServer is starting...");
- //InitEasySetup with sercurity mode disabled for arduino
- if(InitEasySetup(CT_ADAPTER_IP, ssid, passwd, false, EventCallbackInApp) == ES_ERROR)
+ //ESInitEnrollee with sercurity mode disabled for arduino
+ if(ESInitEnrollee(CT_ADAPTER_IP, ssid, passwd, false, EventCallbackInApp) == ES_ERROR)
{
OIC_LOG(ERROR, TAG, "OnBoarding Failed");
return;
OIC_LOG_V(ERROR, TAG, "OnBoarding succeded. Successfully connected to ssid : %s",ssid);
}
-void StartProvisioning()
+void ESInitResources()
{
- OIC_LOG(DEBUG, TAG, "StartProvisioning is invoked...");
+ OIC_LOG(DEBUG, TAG, "ESInitResources is invoked...");
// Initialize the OC Stack in Server mode
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
return;
}
- if (InitProvisioning() == ES_ERROR)
+ if (ESInitProvisioning() == ES_ERROR)
{
OIC_LOG(ERROR, TAG, "Init Provisioning Failed!!");
return;
g_isInitialized = false;
- if (TerminateEasySetup() == ES_ERROR)
+ if (ESTerminateEnrollee() == ES_ERROR)
{
- OIC_LOG(ERROR, TAG, "TerminateEasySetup Failed!!");
+ OIC_LOG(ERROR, TAG, "ESTerminateEnrollee Failed!!");
return;
}
break;
case 'P': // start provisioning
- StartProvisioning();
+ ESInitResources();
break;
case 'T': // stop easy setup
if (WiFi.status() == WL_CONNECTED)
is_connected = true;
else if (is_connected)
- TerminateEasySetup();
+ ESTerminateEnrollee();
// Give CPU cycles to OCStack to perform send/recv and other OCStack stuff
if (OCProcess() != OC_STACK_OK)
printf("============\n");
}
-void EventCallbackInApp(ESResult esResult, EnrolleeState enrolleeState)
+void EventCallbackInApp(ESResult esResult, ESEnrolleeState enrolleeState)
{
printf("Easy setup event callback\n");
{
printf("StartEasySetup and onboarding started..\n");
- if(InitEasySetup(CT_ADAPTER_IP, ssid, passwd, gIsSecured, EventCallbackInApp) == ES_ERROR)
+ if(ESInitEnrollee(CT_ADAPTER_IP, ssid, passwd, gIsSecured, EventCallbackInApp) == ES_ERROR)
{
printf("StartEasySetup and onboarding Fail!!\n");
return;
}
}
-void StartOICStackAndStartResources()
+void ESInitResources()
{
printf("Starting Enrollee Provisioning\n");
return;
}
- if (InitProvisioning() == ES_ERROR)
+ if (ESInitProvisioning() == ES_ERROR)
{
printf("Init Provisioning Failed!!\n");
return;
printf("Thread creation failed\n");
}
- printf("InitProvisioning Success\n");
+ printf("ESInitProvisioning Success\n");
}
void StopEasySetup()
{
printf("StopEasySetup IN\n");
- if (TerminateEasySetup() == ES_ERROR)
+ if (ESTerminateEnrollee() == ES_ERROR)
{
- printf("TerminateEasySetup Failed!!\n");
+ printf("ESTerminateEnrollee Failed!!\n");
return;
}
case 'P': // start provisioning
case 'p':
- StartOICStackAndStartResources();
+ ESInitResources();
break;
case 'T': // stop easy setup
cout<<"============"<<endl;
}
-void EventCallbackInApp(ESResult esResult, EnrolleeState enrolleeState)
+void EventCallbackInApp(ESResult esResult, ESEnrolleeState enrolleeState)
{
cout<<"Easy setup event callback"<<endl;
{
cout<<"StartEasySetup and onboarding started.."<<endl;
- if(InitEasySetup(CT_ADAPTER_IP, ssid, passwd, gIsSecured, EventCallbackInApp) == ES_ERROR)
+ if(ESInitEnrollee(CT_ADAPTER_IP, ssid, passwd, gIsSecured, EventCallbackInApp) == ES_ERROR)
{
cout<<"StartEasySetup and onboarding Fail!!"<<endl;
return;
}
}
-void StartOICStackAndStartResources()
+void ESInitResources()
{
cout<<"Starting Enrollee Provisioning"<<endl;
return;
}
- if (InitProvisioning() == ES_ERROR)
+ if (ESInitProvisioning() == ES_ERROR)
{
cout<<"Init Provisioning Failed!!"<<endl;
return;
cout<<"Thread creation failed"<<endl;
}
- cout<<"InitProvisioning Success"<<endl;
+ cout<<"ESInitProvisioning Success"<<endl;
}
void StopEasySetup()
{
cout<<"StopEasySetup IN"<<endl;
- if (TerminateEasySetup() == ES_ERROR)
+ if (ESTerminateEnrollee() == ES_ERROR)
{
- cout<<"TerminateEasySetup Failed!!"<<endl;
+ cout<<"ESTerminateEnrollee Failed!!"<<endl;
return;
}
case 'P': // start provisioning
case 'p':
- StartOICStackAndStartResources();
+ ESInitResources();
break;
case 'T': // stop easy setup