#include <service_app.h>
#include <string.h>
#include <stdlib.h>
-#include <Ecore.h>
+#include <glib.h>
-#include "st_things.h"
#include "log.h"
#include "sensor-data.h"
#include "co2-sensor.h"
-#define JSON_NAME "device_def.json"
-#define SENSOR_URI_CO2 "/capability/airQualitySensor/main/0"
-#define SENSOR_KEY_CO2 "airQuality"
-#define SENSOR_KEY_RANGE "range"
-
#define SENSOR_CH_CO2 (0)
-#define SENSOR_GATHER_INTERVAL (0.05f)
+#define SENSOR_GATHER_INTERVAL (50) //50ms
#define SENSOR_GATHER_COUNT (60)
-//#define USE_ST_SDK
+#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_URI_CO2 "/capability/airQualitySensor/main/0"
+#define SENSOR_KEY_CO2 "airQuality"
+
+#endif /* USE_ST_SDK */
typedef struct app_data_s {
- Ecore_Timer *getter_co2;
+ guint getter_co2;
sensor_data *co2_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 __get_co2(void *data)
+#ifdef USE_ST_SDK
+
+/* smartthings resource functions */
+static const char *
+__resource_error_to_str(smartthings_resource_error_e error)
{
- int ret = 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;
+ }
+
+ return err_str;
+}
+
+static bool
+handle_get_co2(smartthings_payload_h resp_payload, void *user_data)
+{
+ app_data *ad = user_data;
unsigned int value = 0;
- static unsigned int sum = 0;
- static unsigned int count = 0;
- app_data *ad = data;
+ retv_if(!ad, false);
- if (!ad) {
- _E("failed to get app_data");
- service_app_exit();
- return ECORE_CALLBACK_CANCEL;
+ sensor_data_get_uint(ad->co2_data, &value);
+ smartthings_payload_set_int(resp_payload, SENSOR_KEY_CO2, (int)value);
+
+ return true;
+}
+
+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;
+
+ _D("request on %s, type[%d], id[%d]", uri, req_type, req_id);
+
+ smartthings_payload_create(&resp_payload);
+ if (!resp_payload) {
+ _E("Response payload is NULL");
+ return;
}
- if (!ad->co2_data) {
- _E("failed to get co2_data");
- service_app_exit();
- ad->getter_co2 = NULL;
- return ECORE_CALLBACK_CANCEL;
+ if (req_type == SMARTTHINGS_RESOURCE_REQUEST_GET) {
+ if (0 == g_strcmp0(uri, SENSOR_URI_CO2))
+ result = handle_get_co2(resp_payload, user_data);
+ else
+ _E("No matching Resource uri to get");
+ } else if (req_type == SMARTTHINGS_RESOURCE_REQUEST_SET) {
+ _E("No matching Resource uri to set");
+ } else {
+ _E("Invalid request type - %d", req_type);
+ smartthings_payload_destroy(resp_payload);
+ return;
}
- ret = co2_sensor_read(SENSOR_CH_CO2, &value);
- retv_if(ret != 0, ECORE_CALLBACK_RENEW);
+ 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;
+ }
- count++;
- sum += value;
+ 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 (count == SENSOR_GATHER_COUNT) {
- unsigned int avg = 0;
- avg = sum/SENSOR_GATHER_COUNT;
+ if (smartthings_payload_destroy(resp_payload))
+ _E("smartthings_payload_destroy failed");
- _D("co2 avg - [%u], [%u ppm]", avg, co2_sensor_value_to_ppm(avg));
+ return;
+}
- sensor_data_set_uint(ad->co2_data, avg);
+static void
+_resource_connection_status_cb(smartthings_resource_h handle,
+ smartthings_resource_connection_status_e status, void *user_data)
+{
+ app_data *ad = user_data;
-#ifdef USE_ST_SDK
- st_things_notify_observers(SENSOR_URI_CO2);
-#endif
- count = 0;
- sum = 0;
+ _D("status=[%d]", status);
+
+ ret_if(!ad);
+
+ ad->st_res_conn_status = status;
+
+ 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("connection failed");
+ }
+ return;
+}
+
+static int
+st_thing_notify_resource(app_data *ad, const char *uri, const char *key, sensor_data *data)
+{
+ 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;
+
+ 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);
+
+ handle = ad->st_res_h;
+
+ data_type = sensor_data_get_type(data);
+ retv_if(data_type == SENSOR_DATA_TYPE_NONE, -1);
+
+ smartthings_payload_create(&payload);
+ if (!payload) {
+ _E("failed to create payload is NULL");
+ return -1;
+ }
+
+ 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 ECORE_CALLBACK_RENEW;
+ 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 void gathering_start(void *data)
+static int st_thing_resource_init(app_data *ad)
{
- app_data *ad = data;
- ret_if(!ad);
+ smartthings_resource_h st_res_h = NULL;
+ int error = 0;
- if (ad->getter_co2)
- ecore_timer_del(ad->getter_co2);
+ retv_if(!ad, -1);
+ if (ad->st_res_h) {
+ _I("Already initialized!");
+ return 0;
+ }
- ad->getter_co2 = ecore_timer_add(SENSOR_GATHER_INTERVAL, __get_co2, ad);
- if (!ad->getter_co2)
- _E("Failed to add getter_co2");
+ 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;
+ }
- return;
+ ad->st_res_h = st_res_h;
+ ad->st_res_conn_status = SMARTTHINGS_RESOURCE_CONNECTION_STATUS_DISCONNECTED;
+
+ return 0;
}
-#ifdef USE_ST_SDK
-static bool handle_reset_request(void)
+static int st_thing_resource_fini(app_data *ad)
{
- _D("Received a request for RESET.");
- return false;
+ retv_if(!ad, -1);
+
+ if (!ad->st_res_h)
+ return 0;
+
+ smartthings_resource_unset_request_cb(ad->st_res_h);
+ smartthings_resource_deinitialize(ad->st_res_h);
+
+ ad->st_res_h = NULL;
+ ad->st_res_conn_status = SMARTTHINGS_RESOURCE_CONNECTION_STATUS_DISCONNECTED;
+
+ return 0;
}
-static void handle_reset_result(bool result)
+/* smartthings master functions */
+static const char *__master_error_to_str(smartthings_error_e error)
{
- _D("Reset %s.\n", result ? "succeeded" : "failed");
+ 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 bool handle_ownership_transfer_request(void)
+static void _user_confirm_cb(smartthings_h handle, void *user_data)
{
- _D("Received a request for Ownership-transfer.");
- return true;
+ if (smartthings_send_user_confirm(handle, true) != 0)
+ _E("smartthings_send_user_confirm() is failed");
}
-static void handle_things_status_change(st_things_status_e things_status)
+static void _reset_confirm_cb(smartthings_h handle, void *user_data)
{
- _D("Things status is changed: %d\n", things_status);
+ if (smartthings_send_reset_confirm(handle, true) != 0)
+ _E("smartthings_send_reset_confirm() is failed");
+}
- if (things_status == ST_THINGS_STATUS_REGISTERED_TO_CLOUD)
- ecore_main_loop_thread_safe_call_async(gathering_start, g_ad);
+static void _reset_result_cb(smartthings_h handle, bool result, void *user_data)
+{
+ _I("reset result = [%d]", result);
}
-static bool handle_get_request(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep)
+static void
+_thing_status_cb(
+ smartthings_h handle, smartthings_status_e status, void *user_data)
{
- _D("resource_uri [%s]", req_msg->resource_uri);
- retv_if(!g_ad, false);
+ _D("status: [%d]", status);
+}
- if (0 == strcmp(req_msg->resource_uri, SENSOR_URI_CO2)) {
- _D("query : %s, property: %s", req_msg->query, req_msg->property_key);
+static void
+_things_connection_status_cb(smartthings_h handle, smartthings_connection_status_e status,
+ void *user_data)
+{
+ _D("status = [%d]", status);
+
+ if (status == SMARTTHINGS_CONNECTION_STATUS_CONNECTED) {
+ int err = 0;
+ bool is_es_completed = false;
+ const char* dev_name = "co2-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;
+ }
- if (req_msg->has_property_key(req_msg, SENSOR_KEY_CO2)) {
- unsigned int value = 0;
- sensor_data_get_uint(g_ad->co2_data, &value);
- resp_rep->set_int_value(resp_rep, SENSOR_KEY_CO2, value);
+ 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;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+
+ err = smartthings_start(handle);
+ if (err) {
+ _E("smartthings_start() is failed, [%s]",
+ __master_error_to_str(err));
+ return;
+ }
+
+ 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;
+ }
+
+ if (is_es_completed == true) {
+ _I("Easysetup is already done");
+ return;
}
- if (req_msg->has_property_key(req_msg, SENSOR_KEY_RANGE)) {
- const double range[2] = { 0.0, 1024.0 };
- resp_rep->set_double_array_value(resp_rep, SENSOR_KEY_RANGE, range, 2);
+
+ err = smartthings_start_easysetup(handle);
+ if (err) {
+ _E("smartthings_start_easysetup() is failed, [%s]",
+ __master_error_to_str(err));
+ smartthings_stop(handle);
+ return;
}
- return true;
+ } else {
+ _E("connection failed");
}
- _E("not supported uri");
- return false;
+ return;
}
-static bool handle_set_request(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep)
+static int st_thing_master_init(app_data *ad)
{
- _D("resource_uri [%s]", req_msg->resource_uri);
- return false;
-}
+ int err = 0;
+ smartthings_h st_handle = NULL;
-static int __things_init(void)
-{
- 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;
- }
+ retv_if(!ad, -1);
- app_data_path = app_get_data_path();
- if (!app_data_path) {
- _E("app_data_path is NULL!!");
- free(app_res_path);
- return -1;
+ if (ad->st_master_h) {
+ _I("Already initialized!");
+ return 0;
}
- 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;
- 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);
- st_things_register_request_cb(handle_get_request, handle_set_request);
- st_things_register_reset_cb(handle_reset_request, handle_reset_result);
- st_things_register_user_confirm_cb(handle_ownership_transfer_request);
- 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 __get_co2(gpointer user_data)
{
- st_things_deinitialize();
- return 0;
+ int ret = 0;
+ unsigned int value = 0;
+ static unsigned int sum = 0;
+ static unsigned int count = 0;
+
+ app_data *ad = user_data;
+
+ if (!ad) {
+ _E("failed to get app_data");
+ service_app_exit();
+ return FALSE;
+ }
+
+ if (!ad->co2_data) {
+ _E("failed to get co2_data");
+ service_app_exit();
+ ad->getter_co2 = 0;
+ return FALSE;
+ }
+
+ ret = co2_sensor_read(SENSOR_CH_CO2, &value);
+ retv_if(ret != 0, TRUE);
+
+ count++;
+ sum += value;
+
+ if (count == SENSOR_GATHER_COUNT) {
+ unsigned int avg = 0;
+ avg = sum/SENSOR_GATHER_COUNT;
+
+ _D("co2 avg - [%u], [%u ppm]", avg, co2_sensor_value_to_ppm(avg));
+
+ sensor_data_set_uint(ad->co2_data, avg);
+
+#ifdef USE_ST_SDK
+ st_thing_notify_resource(ad, SENSOR_URI_CO2, SENSOR_KEY_CO2, ad->co2_data);
+#endif
+ count = 0;
+ sum = 0;
+ }
+
+ return TRUE;
}
-static int __things_start(void)
+static void gathering_stop(void *data)
{
- st_things_start();
- return 0;
+ app_data *ad = data;
+ ret_if(!ad);
+
+ if (ad->getter_co2) {
+ g_source_remove(ad->getter_co2);
+ ad->getter_co2 = 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_co2 = g_timeout_add(SENSOR_GATHER_INTERVAL, __get_co2, ad);
+ if (!ad->getter_co2)
+ _E("Failed to add getter_co2");
}
-#endif /* USE_ST_SDK */
static bool service_app_create(void *user_data)
{
return false;
#ifdef USE_ST_SDK
- if (__things_init())
+ 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)
{
-#ifdef USE_ST_SDK
- __things_start();
-#else
+ gathering_stop(user_data);
gathering_start(user_data);
-#endif
}
static void service_app_terminate(void *user_data)
if (!ad)
return;
- if (ad->getter_co2)
- ecore_timer_del(ad->getter_co2);
-
#ifdef USE_ST_SDK
- __things_stop();
- __things_deinit();
+ st_thing_resource_fini(ad);
+ st_thing_master_fini(ad);
#endif
sensor_data_free(ad->co2_data);
projects / apps / native / st-things-co2-meter.git / blobdiff