#include <gio/gio.h>
#include <fcntl.h>
#include <sys/stat.h>
+#include <pthread.h>
#include <ocstack.h>
#include <ocpayload.h>
#include <octypes.h>
#include <ocprovisioningmanager.h>
#include <rd_client.h>
+#include <oickeepalive.h>
+
+#include <ckmc/ckmc-manager.h>
#include <controlee_firmware_resource.h>
#define DEFAULT_CONTEXT_VALUE 0x99
#define LOGIN_OK 4
-#define CERT_FILE_PATH "/opt/usr/data/ua-client/thawte.cert.pem"
-
+#define OC_SECURITY_SQL_DB_FILE_NAME "/opt/usr/data/ua-client/PDM.db"
+#define OC_CONTROLEE_DAT_FILE_PATH "/opt/usr/data/ua-client/oic_svr_db_client.dat"
+#define CERT_FILE_PATH "/opt/usr/data/ua-client/thawte.cert.pem"
OCResourceHandle aircon_handle = NULL;
OCResourceHandle binary_switch_handle = NULL;
OCResourceHandle firmware_handle = NULL;
-#define STG_SERVER "52.202.112.20:443"
-#define DEV_SERVER "54.86.109.131:443"
-#define AUTH_PROVIDER "samsung-us"
+#define CLOUD_STG_SERVER "52.202.112.20:443"
+#define CLOUD_DEV_SERVER "54.86.109.131:443"
+#define CLOUD_AUTH_PROVIDER "samsung-us"
+#define CLOUD_DEVICE_TYPE "device"
+
+#define DEVICE_ID "di"
+#define CLIENT_ID "clientid"
+#define AUTH_PROVIDER "authprovider"
+#define DEVICE_TYPE "devicetype"
+#define ACCESS_TOKEN "accesstoken"
+#define USER_ID "uid"
+#define CLOUD_LOGIN "login"
+
+#define CLOUD_ACCOUNT_RES_TYPE "oic.wk.account"
+#define CLOUD_SESSION_RES_TYPE "oic.wk.session"
-uint8_t *g_certificate;
-size_t g_cert_len;
-OicEncodingType_t g_cert_encoding_type = OIC_ENCODING_PEM;
+#define MAX_INTERVAL_NUMBER (4)
+
+typedef struct
+{
+ char *deviceId;
+ char *clientId;
+ char *authCode;
+ char *uid;
+ char *accessToken;
+ char *refreshToken;
+ char *codeVerifier;
+
+ uint8_t *certificate;
+ size_t certificateLength;
+ OicEncodingType_t encodingType;
+} CloudLoginInfo;
+
+
+bool bSignin;
+bool isExit;
uint16_t g_cred_id = 0;
-char *g_accesstoken;
-char *g_refreshtoken;
-char *g_tokentype;
-long g_expiresin;
-char *g_uid;
-char *g_redirecturi;
-char *g_sid;
+CloudLoginInfo loginDetails;
+
+static pthread_mutex_t pingcycle_mutex = PTHREAD_MUTEX_INITIALIZER;
+static bool is_ping_timer = false;
+
+
+OCPlatformInfo g_platform_info = {
+ "1234", /* platformID */
+ "Samsung", /* manufacturerName */
+ "https://www.example.com", /* manufacturerUrl */
+ "Tizen2017-AAA", /* modelNumber */
+ "2017-07-19", /* dateOfManufacture */
+ "AAA", /* platformVersion */
+ "4.0", /* operatingSystemVersion */
+ "HW-001", /* hardwareVersion */
+ "1.0", /* firmwareVersion */
+ "https://www.examplesupport.com", /* supportUrl */
+ "2017-07-19T12.00" /* systemTime */
+};
+
+
+int _signin();
+int _signup();
+
+
+int _set_auth_cert_info()
+{
+ char *certFile = CERT_FILE_PATH;
+ ckmc_cert_s* cert = NULL;
+ int ret_cert = ckmc_load_cert_from_file(certFile, &cert);
+ if (CKMC_ERROR_NONE != ret_cert) {
+ printf("ckmc_load_cert_from_file error [%d]\n", ret_cert);
+ return -1;
+ }
+
+ if (loginDetails.certificate) {
+ free(loginDetails.certificate);
+ loginDetails.certificate = NULL;
+ }
+
+ loginDetails.certificateLength = cert->cert_size;
+ loginDetails.certificate = (uint8_t *)calloc(1, sizeof(uint8_t)*cert->cert_size + 1);
+ loginDetails.encodingType = OIC_ENCODING_PEM;
+
+ if (loginDetails.certificate) {
+ memcpy(loginDetails.certificate, cert->raw_cert, sizeof(uint8_t)*cert->cert_size);
+
+ printf("Save cert file Data\n");
+ if (OCSaveTrustCertChain(loginDetails.certificate, loginDetails.certificateLength, \
+ loginDetails.encodingType, &g_cred_id) != OC_STACK_OK) {
+ printf("OCSaveTrustCertChain() failed\n");
+ return -1;
+ } else {
+ printf("Cred ID from saveCertFile = [%d]\n", g_cred_id);
+ }
+ }
+
+ return 0;
+}
+
+static FILE *client_open(const char *path, const char *mode)
+{
+ (void)path;
+
+ if (!strcmp(mode, "rb"))
+ mode = strdup("r");
+ else if(!strcmp(mode, "wb"))
+ mode = strdup("w");
+
+ return fopen(OC_CONTROLEE_DAT_FILE_PATH, mode);
+}
+
+
+
+static void _parse_payload(OCRepPayload *payload)
+{
+ if (!payload)
+ return;
+
+ char *sid, *certificate;
+ if (!OCRepPayloadGetPropString(payload, "sid", &sid))
+ printf("Can't get 'sid'\n");
+
+ if (!OCRepPayloadGetPropString(payload, "certificate", &certificate))
+ printf("Can't get 'certificate'\n");
+
+}
+
+static OCStackApplicationResult _send_keep_alive_cb(void *context, OCDoHandle handle,
+ OCClientResponse * clientResponse)
+{
+ printf("_send_keep_alive_cb() is called\n");
+
+ (void)context;
+ (void)handle;
+
+ if(clientResponse->result > OC_STACK_RESOURCE_CHANGED) {
+ pthread_detach(pthread_self());
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = false;
+ pthread_mutex_unlock(&pingcycle_mutex);
+ pthread_exit(NULL);
+ }
+
+ return OC_STACK_DELETE_TRANSACTION;
+}
-static void _session_parse_payload(OCRepPayload *payload)
+static void _keep_alive_cb(OCRepPayload *payload)
{
+ printf("_keep_alive_cb() is called\n");
+
if (!payload)
return;
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_ACCESS_TOKEN, &g_accesstoken))
- printf("Can't get: %s\n", OC_RSRVD_ACCESS_TOKEN);
+ char *intervals;
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_REFRESH_TOKEN, &g_refreshtoken))
- printf("Can't get: %s\n", OC_RSRVD_REFRESH_TOKEN);
+ if (OCRepPayloadGetPropString(payload, "inarray", &intervals)) {
+ printf("[keep alive cb] intervals=[%s]\n", intervals);
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_TOKEN_TYPE, &g_tokentype))
- printf("Can't get: %s\n", OC_RSRVD_TOKEN_TYPE);
+ char *temp_intervals = strdup(intervals);
+ char *token = NULL;
+ int interval[4] = {0};
+ int i = 0;
- int64_t tmp = 0;
- if (!OCRepPayloadGetPropInt(payload, OC_RSRVD_EXPIRES_IN, &tmp))
- printf("Can't get: %s\n", OC_RSRVD_EXPIRES_IN);
- else
- g_expiresin = tmp;
+ token = strtok(temp_intervals, "[");
+ token = strtok(token, "]");
+ token = strtok(token, ",");
+ interval[0] = atoi(token);
+ ++i;
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_USER_UUID, &g_uid))
- printf("Can't get: %s\n", OC_RSRVD_USER_UUID);
+ while ((token = strtok(NULL, ", "))) {
+ interval[i] = atoi(token);
+ ++i;
+ }
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_REDIRECT_URI, &g_redirecturi))
- printf("Can't get: %s\n", OC_RSRVD_REDIRECT_URI);
+ // Send KeepAlive each interval
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = true;
+ pthread_mutex_unlock(&pingcycle_mutex);
+
+ i = 0;
+ int timeout = 0;
+ int timer_count = 0;
+
+ while (is_ping_timer) {
+ if(timeout == timer_count) {
+ timer_count = 0;
+ OCStackResult ocResult = OC_STACK_ERROR;
+
+ if(i >= MAX_INTERVAL_NUMBER) {
+ i = MAX_INTERVAL_NUMBER - 1;
+ }
+
+ OCRepPayload *payload = OCRepPayloadCreate();
+ if (!payload) break;
+
+ OCRepPayloadSetPropInt(payload, "in", (int64_t)interval[i]);
+ timeout = interval[i] * 60;
+ ++i;
+
+ char uri[MAX_URI_LENGTH] = { 0 };
+ snprintf(uri, MAX_URI_LENGTH, "coap+tcp://%s%s",
+ CLOUD_STG_SERVER, OC_RSRVD_ACCOUNT_URI);
+
+ OCCallbackData *cbData = (OCCallbackData *)calloc(1, sizeof(OCCallbackData));
+ cbData->cb = _send_keep_alive_cb;
+ cbData->context = (void *)DEFAULT_CONTEXT_VALUE;
+
+ ocResult = OCSendKeepAliveRequest(NULL, uri, (OCPayload *)payload, cbData);
+ printf("sendKeepAliveRequest() result : %d\n", ocResult);
+ if (OC_STACK_OK != ocResult) {
+ pthread_detach(pthread_self());
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = false;
+ pthread_mutex_unlock(&pingcycle_mutex);
+ pthread_exit(NULL);
+ }
+ }
- char *tmp_cert;
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_CERTIFICATE, &tmp_cert))
- printf("Can't get: %s\n", OC_RSRVD_CERTIFICATE);
- else
- g_certificate = (uint8_t *)tmp_cert;
+ pthread_mutex_lock(&pingcycle_mutex);
+ ++timer_count;
+ pthread_mutex_unlock(&pingcycle_mutex);
- if (!OCRepPayloadGetPropString(payload, OC_RSRVD_SUBJECT_ID, &g_sid))
- printf("Can't get: %s\n", OC_RSRVD_SUBJECT_ID);
+ sleep(1);
+ }
+
+ g_free(token);
+ g_free(temp_intervals);
+ } else {
+ pthread_detach(pthread_self());
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = false;
+ pthread_mutex_unlock(&pingcycle_mutex);
+ pthread_exit(NULL);
+ }
+
+ return;
}
-static OCStackApplicationResult _handle_signup_response(void *ctx,
+
+void _set_platform_info()
+{
+ printf("_set_platform_info() is called\n");
+
+ if (OCSetPlatformInfo(g_platform_info) == OC_STACK_OK) {
+ printf("Platform Registration is succeeded\n");
+ } else {
+ printf("Platform Registration is failed\n");
+ }
+}
+
+
+void _set_device_info()
+{
+ printf("_set_device_info() is called\n");
+
+ OCDeviceInfo devInfoAirConditioner;
+ OCStringLL deviceType;
+
+ deviceType.value = "oic.d.airconditioner";
+ deviceType.next = NULL;
+ devInfoAirConditioner.deviceName = "FAC_2016";
+ devInfoAirConditioner.types = &deviceType;
+ devInfoAirConditioner.specVersion = NULL;
+ devInfoAirConditioner.dataModelVersions = NULL;
+
+ if (OCSetDeviceInfo(devInfoAirConditioner) != OC_STACK_OK) {
+ printf("OCSetDeviceInfo() failed\n");
+ } else {
+ printf("OCSetDeviceInfo() Success\n");
+ }
+}
+
+void _get_login_info()
+{
+ char tmp[64];
+
+ printf("Enter access_token : ");
+ memset(tmp, 0x00, sizeof(tmp));
+ scanf("%s", tmp);
+ loginDetails.accessToken = g_strdup(tmp);
+ printf("access_token : %s\n", loginDetails.accessToken);
+
+ printf("Enter refresh_token : ");
+ memset(tmp, 0x00, sizeof(tmp));
+ scanf("%s", tmp);
+ loginDetails.refreshToken = g_strdup(tmp);
+ printf("refresh_token : %s\n", loginDetails.refreshToken);
+
+ printf("Enter user_id : ");
+ memset(tmp, 0x00, sizeof(tmp));
+ scanf("%s", tmp);
+ loginDetails.uid = g_strdup(tmp);
+ printf("user_id : %s\n", loginDetails.uid);
+
+ printf("Enter client_id : ");
+ memset(tmp, 0x00, sizeof(tmp));
+ scanf("%s", tmp);
+ loginDetails.clientId = g_strdup(tmp);
+ printf("client_id : %s\n", loginDetails.clientId);
+
+ loginDetails.deviceId = g_strdup(OCGetServerInstanceIDString());
+ printf("Device ID = [%s]\n", loginDetails.deviceId);
+
+}
+
+
+static OCStackApplicationResult _handle_keepalive_cb(void *context, OCDoHandle handle,
+ OCClientResponse * clientResponse)
+{
+ (void)context;
+ (void)handle;
+
+ if (!clientResponse) {
+ printf("Received NULL clientResponse\n");
+ return OC_STACK_DELETE_TRANSACTION;
+ }
+
+ if (clientResponse->payload) {
+ printf("Payload received\n");
+ }
+
+ if (clientResponse->result == OC_STACK_OK) {
+ _keep_alive_cb((OCRepPayload*)clientResponse->payload);
+ }
+
+ return OC_STACK_DELETE_TRANSACTION;
+}
+
+void *_ping_timer(void *timer)
+{
+ OCStackResult ocResult = OC_STACK_ERROR;
+ (void)timer;
+
+ char uri[MAX_URI_LENGTH] = { 0 };
+ snprintf(uri, MAX_URI_LENGTH, "coap+tcp://%s%s",
+ CLOUD_STG_SERVER, OC_RSRVD_ACCOUNT_URI);
+
+ OCCallbackData keepAliveCb = {0,};
+ keepAliveCb.cb = _handle_keepalive_cb;
+ OCFindKeepAliveResource(NULL, uri, &keepAliveCb);
+ printf("OCFindKeepAliveResource() result : %d\n", ocResult);
+
+ if (OC_STACK_OK != ocResult) {
+ pthread_detach(pthread_self());
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = false;
+ pthread_mutex_unlock(&pingcycle_mutex);
+ pthread_exit(NULL);
+ }
+
+ return NULL;
+}
+
+
+static OCStackApplicationResult _handle_signin_response(void *ctx,
OCDoHandle handle,
OCClientResponse *response)
{
if (response->result != LOGIN_OK) {
printf("Login error: %d\n", response->result);
+
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = FALSE;
+ pthread_mutex_unlock(&pingcycle_mutex);
} else {
- _session_parse_payload((OCRepPayload*)response->payload);
- printf("Sign Up OK\n");
+ bSignin = true;
+ printf("Sign In Success\n");
+
+ pthread_t pingThread;
+ pthread_mutex_lock(&pingcycle_mutex);
+ is_ping_timer = true;
+ pthread_mutex_unlock(&pingcycle_mutex);
+
+ int ret = pthread_create(&pingThread, NULL, _ping_timer, NULL);
+ if (ret != 0)
+ printf("ping pthread_create fail!\n");
}
return OC_STACK_DELETE_TRANSACTION;
-}
-
+}
-int _set_auth_cert_info()
+static OCStackApplicationResult _handle_signup_response(void *ctx,
+ OCDoHandle handle,
+ OCClientResponse *response)
{
- int fd;
- FILE *fp;
- uint8_t *data;
- size_t len;
- off_t fsize;
- struct stat st;
-
- fd = open(CERT_FILE_PATH, O_RDONLY);
- if (fd == -1)
- return -1;
+ (void)(ctx);
+ (void)(handle);
- fp = fdopen(fd, "r");
- if (fp == NULL) {
- printf("Failed to open cert file!\n");
- return -1;
+ if (!response) {
+ printf("Received NULL response\n");
+ return OC_STACK_DELETE_TRANSACTION;
}
- if ((fstat(fd, &st) != 0) || (!S_ISREG(st.st_mode)))
- return -1;
+ if (response->payload) {
+ printf("Payload received\n");
+ }
- if (fseeko(fp, 0, SEEK_END) == 0 && ((fsize = ftello(fp)) != -1)) {
- data = (uint8_t *)malloc(fsize);
- len = fsize;
+ if (response->result != LOGIN_OK) {
+ printf("Login error: %d\n", response->result);
} else {
- fclose(fp);
- return -1;
+ _parse_payload((OCRepPayload*)response->payload);
+ printf("Sign Up OK\n");
+ _signin();
}
- rewind(fp);
- size_t readLen = fread(data, 1, len , fp);
- if (readLen != len) {
- printf("Failed to read the cert file\n");
- free(data);
- fclose(fp);
- return -1;
- }
+ return OC_STACK_DELETE_TRANSACTION;
+}
- fclose(fp);
+int _signin()
+{
+ char uri[MAX_URI_LENGTH] = { 0 };
+ snprintf(uri, MAX_URI_LENGTH, "coap+tcp://%s%s",
+ CLOUD_STG_SERVER, OC_RSRVD_ACCOUNT_URI);
+ printf("server uri=[%s]\n", uri);
- g_certificate = data;
- g_cert_len = len;
- if (OCSaveTrustCertChain(g_certificate, g_cert_len, g_cert_encoding_type, &g_cred_id) != OC_STACK_OK) {
- printf("OCSaveTrustCertChain() failed\n");
- return -1;
- }
+ OCCallbackData *cbData = (OCCallbackData *)calloc(1, sizeof(OCCallbackData));
+ cbData->cb = _handle_signin_response;
+ cbData->context = (void *)DEFAULT_CONTEXT_VALUE;
+ cbData->cd = NULL;
- return 0;
-}
+ OCRepPayload *payload = OCRepPayloadCreate();
+ if (!payload) return -1;
-static FILE *client_open(const char *path, const char *mode)
-{
- (void)(path);
- return fopen("/opt/usr/data/controlee-firmware/controlee-firmware-testapp.dat", mode);
+ OCRepPayloadSetPropString(payload, DEVICE_ID, (const char *)loginDetails.deviceId);
+ OCRepPayloadSetPropString(payload, ACCESS_TOKEN, (const char *)loginDetails.accessToken);
+ OCRepPayloadSetPropString(payload, USER_ID, (const char *)loginDetails.uid);
+ OCRepPayloadSetPropBool(payload, CLOUD_LOGIN, true);
+ OCRepPayloadAddResourceType(payload, CLOUD_SESSION_RES_TYPE);
+ OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+
+ int ret;
+ if (OCDoResource(NULL, OC_REST_POST, uri, NULL, (OCPayload *)payload,
+ CT_ADAPTER_TCP, OC_LOW_QOS, cbData, NULL, 0) == OC_STACK_OK) {
+ ret = 0;
+ printf("OCDoResource() is succeeded\n");
+ } else {
+ ret = -1;
+ printf("OCDoResource() is failed\n");
+ }
+
+ return ret;
}
int _signup()
{
- char uri[MAX_URI_LENGTH] = { 0 };
- OCPersistentStorage ps = {client_open, fread, fwrite, fclose, unlink};
- if (OCRegisterPersistentStorageHandler(&ps) != OC_STACK_OK) {
- printf("OCRegisterPersistentStorageHandler() is failed\n");
+ if (bSignin == true) {
+ printf("Already signed-in!\n");
return -1;
}
- if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK) {
- printf("OCInit() failed\n");
- return -1;
- }
+ memset(&loginDetails, 0x00, sizeof(CloudLoginInfo));
+ _get_login_info();
- if (_set_auth_cert_info() != 0) {
- printf("Failed to set cert info\n");
- return -1;
- }
-
- char *authToken = NULL;
- // TODO :: Get auth token from data file :: Must fill authToken
-
- OCUUIdentity deviceId;
- if (OCGetDeviceId(&deviceId) != OC_STACK_OK) {
- printf("OCGetDeviceId() is failed\n");
- return -1;
- }
+ _set_auth_cert_info();
+ char uri[MAX_URI_LENGTH] = { 0 };
snprintf(uri, MAX_URI_LENGTH, "coap+tcp://%s%s",
- STG_SERVER, OC_RSRVD_ACCOUNT_URI);
+ CLOUD_STG_SERVER, OC_RSRVD_ACCOUNT_URI);
+ printf("server uri=[%s]\n", uri);
- OCCallbackData cbData;
- memset(&cbData, 0, sizeof(OCCallbackData));
- cbData.cb = _handle_signup_response;
- //cbData.cd = NULL;
+ OCCallbackData *cbData = (OCCallbackData *)calloc(1, sizeof(OCCallbackData));
+ cbData->cb = _handle_signup_response;
+ cbData->context = (void *)DEFAULT_CONTEXT_VALUE;
+ cbData->cd = NULL;
OCRepPayload *payload = OCRepPayloadCreate();
if (!payload) return -1;
- OCRepPayloadSetPropString(payload, OC_RSRVD_DEVICE_ID, (const char *)deviceId.id);
- OCRepPayloadSetPropString(payload, OC_RSRVD_AUTHPROVIDER, AUTH_PROVIDER);
- OCRepPayloadSetPropString(payload, OC_RSRVD_AUTHCODE, authToken);
+ OCRepPayloadSetPropString(payload, AUTH_PROVIDER, CLOUD_AUTH_PROVIDER);
+ OCRepPayloadSetPropString(payload, DEVICE_TYPE, CLOUD_DEVICE_TYPE);
+ OCRepPayloadSetPropString(payload, DEVICE_ID, (const char *)loginDetails.deviceId);
+ OCRepPayloadSetPropString(payload, CLIENT_ID, (const char *)loginDetails.clientId);
+ OCRepPayloadSetPropString(payload, ACCESS_TOKEN, (const char *)loginDetails.accessToken);
+ OCRepPayloadSetPropString(payload, USER_ID, (const char *)loginDetails.uid);
+ OCRepPayloadAddResourceType(payload, CLOUD_ACCOUNT_RES_TYPE);
+ OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+
+ int ret;
+ if (OCDoResource(NULL, OC_REST_POST, uri, NULL, (OCPayload *)payload,
+ CT_ADAPTER_TCP, OC_LOW_QOS, cbData, NULL, 0) == OC_STACK_OK) {
+ ret = 0;
+ printf("OCDoResource() is succeeded\n");
+ } else {
+ ret = -1;
+ printf("OCDoResource() is failed\n");
+ }
+
+ return ret;
+}
+
- return OCDoResource(NULL, OC_REST_POST, uri, NULL, (OCPayload *)payload,
- CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
+int _initialize_oc_stack()
+{
+ OCPersistentStorage ps = {client_open, fread, fwrite, fclose, unlink};
+ OCRegisterPersistentStorageHandler(&ps);
+
+ if (OCInit(NULL, 0, OC_SERVER) == OC_STACK_OK) {
+ printf("OCInit() succeeded\n");
+ } else {
+ printf("OCInit() failed\n");
+ return -1;
+ }
+
+ if (OCInitPM(OC_SECURITY_SQL_DB_FILE_NAME) == OC_STACK_OK) {
+ printf("OCInitPM() is succeeded!\n");
+ } else {
+ printf("OCInitPM() is failed");
+ return -1;
+ }
+
+ return 0;
}
int _init_default_test_res()
{
+#if 0
+ OCUUIdentity deviceId;
+ if (OCGetDeviceId(&deviceId) == OC_STACK_OK) {
+ printf("OCGetDeviceId() is succeeded\n");
+ } else {
+ printf("OCGetDeviceId() is failed\n");
+ return -1;
+ }
+#endif
+
+ _set_platform_info();
+
+ _set_device_info();
+
/* Create air conditioner resource handle */
if (OCCreateResource(&aircon_handle, "x.com.samsung.da.device",
OC_RSRVD_INTERFACE_DEFAULT,
return -1;
}
- OCDeviceInfo devInfoAirConditioner;
- OCStringLL deviceType;
-
- deviceType.value = "oic.d.airconditioner";
- deviceType.next = NULL;
- devInfoAirConditioner.deviceName = "FAC_2016";
- devInfoAirConditioner.types = &deviceType;
- devInfoAirConditioner.specVersion = NULL;
- devInfoAirConditioner.dataModelVersions = NULL;
-
- if (OCSetDeviceInfo(devInfoAirConditioner) != OC_STACK_OK) {
- printf("OCSetDeviceInfo() failed\n");
- return -1;
- }
-
return 0;
}
cb_data.cb = _handle_rd_publish_callback;
cb_data.context = (void *)DEFAULT_CONTEXT_VALUE;
- if (OCRDPublish(OCF_SERVER_URL, CT_ADAPTER_TCP,
+ if (OCRDPublish(NULL, OCF_SERVER_URL, CT_ADAPTER_TCP,
aircon_handle, 3,
&cb_data, OC_LOW_QOS) != OC_STACK_OK) {
printf("OCRDPublish() failed\n");
cb_data.cb = _handle_rd_delete_callback;
cb_data.context = (void *)DEFAULT_CONTEXT_VALUE;
- if (OCRDDelete(OCF_SERVER_URL, CT_ADAPTER_TCP,
+ if (OCRDDelete(NULL, OCF_SERVER_URL, CT_ADAPTER_TCP,
aircon_handle, 3,
&cb_data, OC_LOW_QOS) != OC_STACK_OK) {
printf("OCRDDelete() failed\n");
printf("============================================\n");
printf("=== Controlee firmware resource test app ===\n");
printf("============================================\n");
- printf(" [A] Sign Up\n");
- printf(" [1] Create default resource)\n");
+ printf(" [A] Sign Up/In\n");
+ printf(" [Z] Sign Out\n");
+ printf(" [1] Create default resource\n");
printf(" [2] Create firmware resource\n");
printf(" [3] Publish resources to RD\n");
printf(" [4] Delete resources from RD\n");
case 'a' :
rv = _signup();
break;
+ case 'Z' :
+ case 'z' :
+ //rv = _signout();
+ break;
case '1':
rv = _init_default_test_res();
break;
return true;
}
+void* _OCProcess_thd(void * ptr)
+{
+ (void) ptr;
+ while (!isExit) {
+ if (OCProcess() != OC_STACK_OK) {
+ printf("OCStack process error\n");
+ return NULL;
+ }
+ }
+
+ return NULL;
+}
+
+
int main(int argc, char *argv[])
{
GMainLoop *mainloop;
g_type_init();
#endif
+ bSignin = false;
+ isExit = false;
mainloop = g_main_loop_new(NULL, false);
+ _initialize_oc_stack();
+
+ pthread_t oc_proc_thd;
+ pthread_create(&oc_proc_thd, NULL, _OCProcess_thd, unlink);
+
_show_menu();
GIOChannel *channel = g_io_channel_unix_new(0);
g_io_add_watch(channel, (G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL), _main_thread, NULL);
projects / platform / core / service / cloud / ua-client.git / commitdiff