From 444185130573dca19232392b1d997ba9a65620ad Mon Sep 17 00:00:00 2001 From: boyeon-son Date: Thu, 22 Nov 2018 08:24:09 +0900 Subject: Update for iot 5.0 Change-Id: Ia6babe5b489a9ed8a81fe51588ffb7c8916afc39 --- src/controller.c | 703 +++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 522 insertions(+), 181 deletions(-) mode change 100755 => 100644 src/controller.c (limited to 'src/controller.c') diff --git a/src/controller.c b/src/controller.c old mode 100755 new mode 100644 index 1c55e50..683294c --- a/src/controller.c +++ b/src/controller.c @@ -18,300 +18,637 @@ #include #include #include -#include +#include +#include -#include "st_things.h" #include "log.h" #include "resource/resource_infrared_motion_sensor.h" #include "resource/resource_led.h" #include "sensor-data.h" -#define JSON_NAME "device_def.json" +#define LED_ON "on" +#define LED_OFF "off" + +#define USE_ST_SDK + +#ifdef USE_ST_SDK + +#include "smartthings.h" +#include "smartthings_resource.h" +#include "smartthings_payload.h" + +/* You have to FIX IT !!! */ +#define CERT_FILE "certificate.pem" // cert file name in 'res' directory +#define PRIV_FILE "privatekey.der" // private key file name in 'res' directory + #define SENSOR_MOTION_URI "/capability/motionSensor/main/0" #define SENSOR_MOTION_KEY "value" +#define SENSOR_MOTION_CH 46 #define SENSOR_LED_URI "/capability/switch/main/0" #define SENSOR_LED_KEY "power" #define SENSOR_LED_INIT "off" +#define SENSOR_LED_CH 130 +#define SENSOR_GATHER_INTERVAL (50) //50ms -#define LED_ON "on" -#define LED_OFF "off" - -#define USE_ST_SDK +#endif /* USE_ST_SDK */ typedef struct app_data_s { - Ecore_Timer *getter_motion; + guint getter_motion; sensor_data *motion_data; sensor_data *led_data; +#ifdef USE_ST_SDK + smartthings_h st_master_h; + smartthings_resource_h st_res_h; + smartthings_resource_connection_status_e st_res_conn_status; +#endif /* USE_ST_SDK */ } app_data; static app_data *g_ad = NULL; -static Eina_Bool __change_motion_sensor_data(void *data) +#ifdef USE_ST_SDK + +/* smartthings resource functions */ +static const char * +__resource_error_to_str(smartthings_resource_error_e error) { - uint32_t value = 0; + const char *err_str = NULL; + + switch (error) { + case SMARTTHINGS_RESOURCE_ERROR_NONE: + err_str = "SMARTTHINGS_RESOURCE_ERROR_NONE"; + break; + case SMARTTHINGS_RESOURCE_ERROR_INVALID_PARAMETER: + err_str = "SMARTTHINGS_RESOURCE_ERROR_INVALID_PARAMETER"; + break; + case SMARTTHINGS_RESOURCE_ERROR_OUT_OF_MEMORY: + err_str = "SMARTTHINGS_RESOURCE_ERROR_OUT_OF_MEMORY"; + break; + case SMARTTHINGS_RESOURCE_ERROR_PERMISSION_DENIED: + err_str = "SMARTTHINGS_RESOURCE_ERROR_PERMISSION_DENIED"; + break; + case SMARTTHINGS_RESOURCE_ERROR_NO_DATA: + err_str = "SMARTTHINGS_RESOURCE_ERROR_NO_DATA"; + break; + case SMARTTHINGS_RESOURCE_ERROR_NOT_SUPPORTED: + err_str = "SMARTTHINGS_RESOURCE_ERROR_NOT_SUPPORTED"; + break; + case SMARTTHINGS_RESOURCE_ERROR_OPERATION_FAILED: + err_str = "SMARTTHINGS_RESOURCE_ERROR_NOT_SUPPORTED"; + break; + case SMARTTHINGS_RESOURCE_ERROR_SERVICE_UNAVAILABLE: + err_str = "SMARTTHINGS_RESOURCE_ERROR_SERVICE_UNAVAILABLE"; + break; + default: + err_str = "Unknown error"; + break; + } - // Get value from motion sensor - int ret = resource_read_infrared_motion_sensor(46, &value); + return err_str; +} - if (ret != 0) _E("Cannot read sensor value"); +static bool +handle_get_motion(smartthings_payload_h resp_payload, void *user_data) +{ + app_data *ad = user_data; + bool value = false; - sensor_data_set_bool(g_ad->motion_data, value); + retv_if(!ad, false); - _D("Detected motion value is: %d", value); + sensor_data_get_bool(ad->motion_data, &value); + smartthings_payload_set_bool(resp_payload, SENSOR_MOTION_KEY, value); - // Notify observers of the Motion sensor resource - st_things_notify_observers(SENSOR_MOTION_URI); + _D("Value : %d", value); - return ECORE_CALLBACK_RENEW; + return true; } -static int __change_led_data(void *data, char *state) { - int ret = 0; - app_data *ad = data; +static bool +handle_get_led(smartthings_payload_h resp_payload, void *user_data) +{ + app_data *ad = user_data; + const char *str = NULL; - retv_if(!ad, -1); - retv_if(!ad->led_data, -1); + retv_if(!ad, false); - sensor_data_set_string(g_ad->led_data, state, strlen(state)); + sensor_data_get_string(ad->led_data, &str); - if (0 == strcmp(state, LED_ON)) { - ret = resource_write_led(130, 1); - } else { - ret = resource_write_led(130, 0); + if (!str) { + str = SENSOR_LED_INIT; } - retv_if(ret != 0, -1); + smartthings_payload_set_string(resp_payload, SENSOR_LED_KEY, str); - // Notify observers of the LED resource - st_things_notify_observers(SENSOR_LED_URI); + _D("Power : %s", str); - return 0; +// free(str); + + return true; } -static bool __handle_get_request_on_motion (st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep) +static bool +handle_set_led(smartthings_payload_h resp_payload, void *user_data) { - if (req_msg->has_property_key(req_msg, SENSOR_MOTION_KEY)) { - bool value = false; + app_data *ad = user_data; + const char *str = NULL; + int ret = 0; + + retv_if(!ad, false); + _D("set [%s:%s] == %s", SENSOR_LED_URI, SENSOR_LED_KEY, str); + + smartthings_payload_set_string(resp_payload, SENSOR_LED_KEY, str); + +// ret = __change_led_data(ad, strdup(str)); + + retv_if(ret != 0, false); + +// free(str); + + return true; +} - sensor_data_get_bool(g_ad->motion_data, &value); +static void +_request_cb(smartthings_resource_h handle, int req_id, + const char *uri, smartthings_resource_req_type_e req_type, + smartthings_payload_h payload, void *user_data) +{ + smartthings_payload_h resp_payload = NULL; + bool result = false; + int error = SMARTTHINGS_RESOURCE_ERROR_NONE; - // Update the response representation about the Motion sensor property which is sent to the client - resp_rep->set_bool_value(resp_rep, SENSOR_MOTION_KEY, value); + _D("request on %s, type[%d], id[%d]", uri, req_type, req_id); - _D("Value : %d", value); + smartthings_payload_create(&resp_payload); + if (!resp_payload) { + _E("Response payload is NULL"); + return; + } - return true; + if (req_type == SMARTTHINGS_RESOURCE_REQUEST_GET) { + if (0 == g_strcmp0(uri, SENSOR_MOTION_URI)) + result = handle_get_motion(resp_payload, user_data); + else if (0 == g_strcmp0(uri, SENSOR_LED_URI)) + result = handle_get_led(resp_payload, user_data); + else + _E("No matching Resource uri to get"); + } else if (req_type == SMARTTHINGS_RESOURCE_REQUEST_SET) { + if (0 == g_strcmp0(uri, SENSOR_LED_URI)) + result = handle_set_led(resp_payload, user_data); + else + _E("No matching Resource uri to get"); } else { - _E("not supported property"); + _E("Invalid request type - %d", req_type); + smartthings_payload_destroy(resp_payload); + return; + } - return false; + error = smartthings_resource_send_response(handle, req_id, uri, resp_payload, result); + if (error != SMARTTHINGS_RESOURCE_ERROR_NONE) { + smartthings_payload_destroy(resp_payload); + _E("smartthings_resource_send_response() failed, [%s]", + __resource_error_to_str(error)); + return; } + + if (req_type == SMARTTHINGS_RESOURCE_REQUEST_SET) { + error = smartthings_resource_notify(handle, uri, resp_payload); + if (error != SMARTTHINGS_RESOURCE_ERROR_NONE) + _E("smartthings_resource_notify() failed, [%s]", + __resource_error_to_str(error)); + } + + if (smartthings_payload_destroy(resp_payload)) + _E("smartthings_payload_destroy failed"); + + return; } -static bool __handle_get_request_on_led (st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep) +static void +_resource_connection_status_cb(smartthings_resource_error_e error, + smartthings_resource_h handle, + smartthings_resource_connection_status_e status, void *user_data) { - if (req_msg->has_property_key(req_msg, SENSOR_LED_KEY)) { - const char *str = NULL; - - sensor_data_get_string(g_ad->led_data, &str); + app_data *ad = user_data; - if (!str) { - str = SENSOR_LED_INIT; - } + _D("result [%s], status=[%d]", __resource_error_to_str(error), status); - // Update the response representation about the LED property which is sent to the client - resp_rep->set_str_value(resp_rep, SENSOR_LED_KEY, str); + ret_if(!ad); - _D("Power : %s", str); + ad->st_res_conn_status = status; - return true; + if (status == SMARTTHINGS_RESOURCE_CONNECTION_STATUS_CONNECTED) { + if (smartthings_resource_set_request_cb(handle, _request_cb, ad)) { + _E("smartthings_resource_set_request_cb() is failed"); + return; + } } else { - _E("not supported property"); - - return false; + _E("connection failed"); } + return; } -static bool __handle_set_request_on_led (st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep) +static int +st_thing_notify_resource(app_data *ad, const char *uri, const char *key, sensor_data *data) { - int ret = 0; - char *str = NULL; + smartthings_resource_h handle = NULL; + smartthings_payload_h payload = NULL; + int error = SMARTTHINGS_RESOURCE_ERROR_NONE; + sensor_data_type_e data_type = SENSOR_DATA_TYPE_NONE; - if (req_msg->rep->get_str_value(req_msg->rep, SENSOR_LED_KEY, &str)) { - retv_if(!str, false); + retv_if(!ad, -1); + retv_if(!ad->st_res_h, -1); + retv_if(ad->st_res_conn_status != SMARTTHINGS_RESOURCE_CONNECTION_STATUS_CONNECTED, -1); + retv_if(!uri, -1); + retv_if(!key, -1); + retv_if(!data, -1); - _D("set [%s:%s] == %s", SENSOR_LED_URI, SENSOR_LED_KEY, str); + handle = ad->st_res_h; - // Update the response representation about the LED property which is sent to the client - resp_rep->set_str_value(resp_rep, SENSOR_LED_KEY, str); + data_type = sensor_data_get_type(data); + retv_if(data_type == SENSOR_DATA_TYPE_NONE, -1); - // Turn on LED light - ret = __change_led_data(g_ad, strdup(str)); + smartthings_payload_create(&payload); + if (!payload) { + _E("failed to create payload is NULL"); + return -1; + } - retv_if(ret != 0, false); - } else { - _E("cannot get a string value"); + switch (data_type) { + case SENSOR_DATA_TYPE_INT: + { + int value = 0; + sensor_data_get_int(data, &value); + smartthings_payload_set_int(payload, key, value); + } + break; + case SENSOR_DATA_TYPE_UINT: + { + unsigned int value = 0; + sensor_data_get_uint(data, &value); + smartthings_payload_set_int(payload, key, (int)value); + } + break; + case SENSOR_DATA_TYPE_BOOL: + { + bool value = 0; + sensor_data_get_bool(data, &value); + smartthings_payload_set_bool(payload, key, value); + } + break; + case SENSOR_DATA_TYPE_DOUBLE: + { + double value = 0; + sensor_data_get_double(data, &value); + smartthings_payload_set_double(payload, key, value); + } + break; + case SENSOR_DATA_TYPE_STR: + { + const char *value = NULL; + sensor_data_get_string(data, &value); + smartthings_payload_set_string(payload, key, value); + } + break; + case SENSOR_DATA_TYPE_NONE: + default: + _E("unsupport data type"); + break; + } - return false; + error = smartthings_resource_notify(handle, uri, payload); + if (error != SMARTTHINGS_RESOURCE_ERROR_NONE) + _E("smartthings_resource_notify() failed, [%s]", + __resource_error_to_str(error)); + + smartthings_payload_destroy(payload); + + return 0; +} + +static int st_thing_resource_init(app_data *ad) +{ + smartthings_resource_h st_res_h = NULL; + int error = 0; + + retv_if(!ad, -1); + if (ad->st_res_h) { + _I("Already initialized!"); + return 0; + } + error = smartthings_resource_initialize(&st_res_h, + _resource_connection_status_cb, ad); + if (error) { + _E("smartthings_resource_initialize() is failed, [%s]", + __resource_error_to_str(error)); + return -1; } - free(str); + ad->st_res_h = st_res_h; + ad->st_res_conn_status = SMARTTHINGS_RESOURCE_CONNECTION_STATUS_DISCONNECTED; - return true; + return 0; } -void gathering_start(void *data) +static int st_thing_resource_fini(app_data *ad) { - app_data *ad = data; - ret_if(!ad); + retv_if(!ad, -1); - if (ad->getter_motion) - ecore_timer_del(ad->getter_motion); + if (!ad->st_res_h) + return 0; - ad->getter_motion = ecore_timer_add(1.0f, __change_motion_sensor_data, ad); + smartthings_resource_unset_request_cb(ad->st_res_h); + smartthings_resource_deinitialize(ad->st_res_h); - if (!ad->getter_motion) { - _E("Failed to add infrared motion getter timer"); - } + ad->st_res_h = NULL; + ad->st_res_conn_status = SMARTTHINGS_RESOURCE_CONNECTION_STATUS_DISCONNECTED; - return; + return 0; } -static bool handle_reset_request(void) +/* smartthings master functions */ +static const char *__master_error_to_str(smartthings_error_e error) { - _D("Received a request for RESET."); - return false; + const char *err_str = NULL; + + switch (error) { + case SMARTTHINGS_ERROR_NONE: + err_str = "SMARTTHINGS_ERROR_NONE"; + break; + case SMARTTHINGS_ERROR_INVALID_PARAMETER: + err_str = "SMARTTHINGS_ERROR_INVALID_PARAMETER"; + break; + case SMARTTHINGS_ERROR_OUT_OF_MEMORY: + err_str = "SMARTTHINGS_ERROR_OUT_OF_MEMORY"; + break; + case SMARTTHINGS_ERROR_PERMISSION_DENIED: + err_str = "SMARTTHINGS_ERROR_PERMISSION_DENIED"; + break; + case SMARTTHINGS_ERROR_NO_DATA: + err_str = "SMARTTHINGS_ERROR_NO_DATA"; + break; + case SMARTTHINGS_ERROR_NOT_SUPPORTED: + err_str = "SMARTTHINGS_ERROR_NOT_SUPPORTED"; + break; + case SMARTTHINGS_ERROR_OPERATION_FAILED: + err_str = "SMARTTHINGS_ERROR_OPERATION_FAILED"; + break; + case SMARTTHINGS_ERROR_SERVICE_UNAVAILABLE: + err_str = "SMARTTHINGS_ERROR_SERVICE_UNAVAILABLE"; + break; + default: + err_str = "Unknown error"; + break; + } + + return err_str; } -static void handle_reset_result(bool result) +static void _user_confirm_cb(smartthings_h handle, void *user_data) { - _D("Reset %s.\n", result ? "succeeded" : "failed"); + if (smartthings_send_user_confirm(handle, true) != 0) + _E("smartthings_send_user_confirm() is failed"); } -static bool handle_ownership_transfer_request(void) +static void _reset_confirm_cb(smartthings_h handle, void *user_data) { - _D("Received a request for Ownership-transfer."); - return true; + if (smartthings_send_reset_confirm(handle, true) != 0) + _E("smartthings_send_reset_confirm() is failed"); } -static void handle_things_status_change(st_things_status_e things_status) +static void _reset_result_cb(smartthings_h handle, bool result, void *user_data) { - _D("Things status is changed: %d\n", things_status); + _I("reset result = [%d]", result); +} - if (things_status == ST_THINGS_STATUS_REGISTERED_TO_CLOUD) - ecore_main_loop_thread_safe_call_async(gathering_start, g_ad); +static void +_thing_status_cb( + smartthings_h handle, smartthings_status_e status, void *user_data) +{ + _D("status: [%d]", status); } -static bool handle_get_request(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep) +static void +_things_connection_status_cb(smartthings_error_e error, + smartthings_h handle, smartthings_connection_status_e status, + void *user_data) { - bool ret = false; + _D("result [%s], status = [%d]", __master_error_to_str(error), status); + + if (status == SMARTTHINGS_CONNECTION_STATUS_CONNECTED) { + int err = 0; + bool is_es_completed = false; + const char* dev_name = "motion-light-app"; + int wifi_mode = SMARTTHINGS_WIFI_MODE_11B + | SMARTTHINGS_WIFI_MODE_11G + | SMARTTHINGS_WIFI_MODE_11N; + + int wifi_freq = SMARTTHINGS_WIFI_FREQ_24G | SMARTTHINGS_WIFI_FREQ_5G; + + err = smartthings_set_device_property( + handle, dev_name, wifi_mode, wifi_freq); + if (err) { + _E("smartthings_initialize() is failed, [%s]", + __master_error_to_str(err)); + return; + } + + err = smartthings_set_certificate_file(handle, CERT_FILE, PRIV_FILE); + if (err) { + _E("smartthings_set_certificate_file() is failed, [%s]", + __master_error_to_str(err)); + return; + } - _D("resource_uri [%s]", req_msg->resource_uri); - retv_if(!g_ad, false); + err = smartthings_set_user_confirm_cb(handle, _user_confirm_cb, NULL); + if (err) { + _E("smartthings_set_user_confirm_cb() is failed, [%s]", + __master_error_to_str(err)); + return; + } - if (0 == strcmp(req_msg->resource_uri, SENSOR_MOTION_URI)) { - _D("query : %s, property: %s", req_msg->query, req_msg->property_key); + err = smartthings_set_reset_confirm_cb(handle, _reset_confirm_cb, NULL); + if (err) { + _E("smartthings_set_reset_confirm_cb() is failed, [%s]", + __master_error_to_str(err)); + return; + } - // Call get request function for motion sensor - ret = __handle_get_request_on_motion(req_msg, resp_rep); - } else if (0 == strcmp(req_msg->resource_uri, SENSOR_LED_URI)) { - _D("query : %s, property: %s", req_msg->query, req_msg->property_key); + err = smartthings_set_reset_result_cb(handle, _reset_result_cb, NULL); + if (err) { + _E("smartthings_set_reset_confirm_cb() is failed, [%s]", + __master_error_to_str(err)); + return; + } - // Call get request function for LED - ret = __handle_get_request_on_led(req_msg, resp_rep); - } else { - _E("not supported uri"); - } + err = smartthings_set_status_changed_cb(handle, _thing_status_cb, NULL); + if (err) { + _E("smartthings_set_status_changed_callback() is failed, [%s]", + __master_error_to_str(err)); + return; + } - return ret; -} + err = smartthings_start(handle); + if (err) { + _E("smartthings_start() is failed, [%s]", + __master_error_to_str(err)); + return; + } -static bool handle_set_request(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep) -{ - bool ret = false; + err = smartthings_get_easysetup_status(handle, &is_es_completed); + if (err) { + _E("smartthings_get_easysetup_status() is failed, [%s]", + __master_error_to_str(err)); + return; + } - _D("resource_uri [%s]", req_msg->resource_uri); - retv_if(!g_ad, false); + if (is_es_completed == true) { + _I("Easysetup is already done"); + return; + } - if (0 == strcmp(req_msg->resource_uri, SENSOR_LED_URI)) { - // Call set request function for LED - ret = __handle_set_request_on_led(req_msg, resp_rep); + err = smartthings_start_easysetup(handle); + if (err) { + _E("smartthings_start_easysetup() is failed, [%s]", + __master_error_to_str(err)); + smartthings_stop(handle); + return; + } } else { - _E("not supported uri"); + _E("connection failed"); } - - return ret; + return; } -static int __things_init(void) +static int st_thing_master_init(app_data *ad) { - bool easysetup_complete = false; - char app_json_path[128] = {'\0', }; - char *app_res_path = NULL; - char *app_data_path = NULL; - - app_res_path = app_get_resource_path(); - if (!app_res_path) { - _E("app_res_path is NULL!!"); - return -1; - } + int err = 0; + smartthings_h st_handle = NULL; - app_data_path = app_get_data_path(); - if (!app_data_path) { - _E("app_data_path is NULL!!"); - free(app_res_path); - return -1; + retv_if(!ad, -1); + + if (ad->st_master_h) { + _I("Already initialized!"); + return 0; } - // Specify the read-only and read-write path - if (0 != st_things_set_configuration_prefix_path(app_res_path, app_data_path)) { - _E("st_things_set_configuration_prefix_path() failed!!"); - free(app_res_path); - free(app_data_path); + err = smartthings_initialize(&st_handle, _things_connection_status_cb, NULL); + if (err) { + _E("smartthings_initialize() is failed, [%s]", + __master_error_to_str(err)); return -1; } - free(app_data_path); - snprintf(app_json_path, sizeof(app_json_path), "%s%s", app_res_path, JSON_NAME); - free(app_res_path); + ad->st_master_h = st_handle; - // Specify the device configuration JSON file and change the status of easysetup_complete - if (0 != st_things_initialize(app_json_path, &easysetup_complete)) { - _E("st_things_initialize() failed!!"); - return -1; + return 0; +} + +int st_thing_master_fini(app_data *ad) +{ + retv_if(!ad, -1); + + if (!ad->st_master_h) { + _I("handle is already NULL"); + return 0; } - _D("easysetup_complete:[%d] ", easysetup_complete); + smartthings_unset_user_confirm_cb(ad->st_master_h); + smartthings_unset_reset_confirm_cb(ad->st_master_h); + smartthings_unset_reset_result_cb(ad->st_master_h); + smartthings_unset_status_changed_cb(ad->st_master_h); - // Register callback for handling request get (handle_get_request) and request set (handle_set_request) messages - st_things_register_request_cb(handle_get_request, handle_set_request); - // Register callback for reset confirmation (handle_reset_request) and reset result(handle_reset_result) functions - st_things_register_reset_cb(handle_reset_request, handle_reset_result); - // Register callback for getting user confirmation for ownership transfer (handle_ownership_transfer_request) - st_things_register_user_confirm_cb(handle_ownership_transfer_request); - // Register callback for getting notified when ST Things state changes (handle_things_status_change) - st_things_register_things_status_change_cb(handle_things_status_change); + smartthings_stop_easysetup(ad->st_master_h); + smartthings_stop(ad->st_master_h); + + if (smartthings_deinitialize(ad->st_master_h) != 0) { + _E("smartthings_deinitialize() is failed"); + return -1; + } + ad->st_master_h = NULL; return 0; } -static int __things_deinit(void) +#endif /* USE_ST_SDK */ + +static gboolean __change_motion_sensor_data(gpointer user_data) { - st_things_deinitialize(); - return 0; + int ret = 0; + uint32_t value = 0; + + app_data *ad = user_data; + + if (!ad) { + _E("failed to get app_data"); + service_app_exit(); + return FALSE; + } + + if (!ad->motion_data) { + _E("failed to get motion_data"); + service_app_exit(); + ad->getter_motion = 0; + return FALSE; + } + + ret = resource_read_infrared_motion_sensor(SENSOR_MOTION_CH, &value); + retv_if(ret != 0, TRUE); + + sensor_data_set_bool(ad->motion_data, value); + + _D("Detected motion value is: %d", value); + +#ifdef USE_ST_SDK + // Notify observers of the Motion sensor resource + st_thing_notify_resource(ad, SENSOR_MOTION_URI, SENSOR_MOTION_KEY, ad->motion_data); +#endif + + return TRUE; } -static int __things_start(void) +//static int __change_led_data(void *data, char *state) { +// int ret = 0; +// app_data *ad = data; +// +// retv_if(!ad, -1); +// retv_if(!ad->led_data, -1); +// +// sensor_data_set_string(ad->led_data, state, strlen(state)); +// +// if (0 == strcmp(state, LED_ON)) { +// ret = resource_write_led(SENSOR_LED_CH, 1); +// } else { +// ret = resource_write_led(SENSOR_LED_CH, 0); +// } +// +// retv_if(ret != 0, -1); +// +//#ifdef USE_ST_SDK +// // Notify observers of the LED resource +// st_thing_notify_resource(ad, SENSOR_LED_URI, SENSOR_LED_KEY, ad->motion_data); +//#endif +// +// return 0; +//} + +static void gathering_stop(void *data) { - st_things_start(); - return 0; + app_data *ad = data; + ret_if(!ad); + + if (ad->getter_motion) { + g_source_remove(ad->getter_motion); + ad->getter_motion = 0; + } } -static int __things_stop(void) +static void gathering_start(void *data) { - st_things_stop(); - return 0; + app_data *ad = data; + ret_if(!ad); + ad->getter_motion = g_timeout_add(SENSOR_GATHER_INTERVAL, __change_motion_sensor_data, ad); + if (!ad->getter_motion) + _E("Failed to add getter_motion"); } static bool service_app_create(void *user_data) @@ -330,33 +667,38 @@ static bool service_app_create(void *user_data) if (!ad->led_data) return false; - sensor_data_set_string(g_ad->led_data, SENSOR_LED_INIT, strlen(SENSOR_LED_INIT)); + sensor_data_set_string(ad->led_data, SENSOR_LED_INIT, strlen(SENSOR_LED_INIT)); - if (__things_init()) +#ifdef USE_ST_SDK + if (st_thing_master_init(ad)) return false; + if (st_thing_resource_init(ad)) { + st_thing_master_fini(ad); + return false; + } +#endif + return true; } static void service_app_control(app_control_h app_control, void *user_data) { - __things_start(); + gathering_stop(user_data); + gathering_start(user_data); } static void service_app_terminate(void *user_data) { app_data *ad = (app_data *)user_data; - // Delete ecore timer - if (ad->getter_motion) - ecore_timer_del(ad->getter_motion); - - // Stop and deinitialize things - __things_stop(); - __things_deinit(); +#ifdef USE_ST_SDK + st_thing_resource_fini(ad); + st_thing_master_fini(ad); +#endif // Turn off LED light with __set_led() - __change_led_data(ad, LED_OFF); +// __change_led_data(ad, LED_OFF); // Free sensor Motion & LED data sensor_data_free(ad->motion_data); @@ -388,4 +730,3 @@ int main(int argc, char *argv[]) return service_app_main(argc, argv, &event_callback, ad); } - -- cgit v1.2.3