526 lines
16 KiB
C
526 lines
16 KiB
C
#include "infra_config.h"
|
|
|
|
#ifdef INFRA_COMPAT
|
|
#include <string.h>
|
|
#include "infra_types.h"
|
|
#include "infra_defs.h"
|
|
#include "infra_state.h"
|
|
#include "infra_compat.h"
|
|
#if defined(INFRA_LOG)
|
|
#include "infra_log.h"
|
|
#endif
|
|
#if defined(INFRA_MEM_STATS)
|
|
#include "infra_mem_stats.h"
|
|
#endif
|
|
|
|
#include "wrappers.h"
|
|
|
|
/*sdk_impl_ctx_t g_sdk_impl_ctx = {0};*/
|
|
|
|
#if !defined(INFRA_LOG)
|
|
void IOT_SetLogLevel(IOT_LogLevel level) {}
|
|
#endif
|
|
|
|
#if defined(WIFI_PROVISION_ENABLED)
|
|
extern void awss_set_press_timeout_ms(unsigned int timeout_ms);
|
|
extern void awss_set_channel_scan_interval_ms(uint32_t timeout_ms);
|
|
#endif
|
|
|
|
static char http_custom_domain[IOTX_DOMAIN_MAX_LEN + 1] = {0};
|
|
static iotx_dev_meta_info_t g_dev_meta_info_t = {0};
|
|
/* global variable for mqtt construction */
|
|
static iotx_conn_info_t g_iotx_conn_info = {0};
|
|
static char g_empty_string[1] = "";
|
|
|
|
int IOT_SetupConnInfo(const char *product_key,
|
|
const char *device_name,
|
|
const char *device_secret,
|
|
void **info_ptr)
|
|
{
|
|
if (product_key == NULL || device_name == NULL || device_secret == NULL ||
|
|
strlen(product_key) > IOTX_PRODUCT_KEY_LEN ||
|
|
strlen(device_name) > IOTX_DEVICE_NAME_LEN ||
|
|
strlen(device_secret) > IOTX_DEVICE_SECRET_LEN)
|
|
{
|
|
return NULL_VALUE_ERROR;
|
|
}
|
|
|
|
if (info_ptr)
|
|
{
|
|
memset(&g_iotx_conn_info, 0, sizeof(iotx_conn_info_t));
|
|
g_iotx_conn_info.host_name = g_empty_string;
|
|
g_iotx_conn_info.client_id = g_empty_string;
|
|
g_iotx_conn_info.username = g_empty_string;
|
|
g_iotx_conn_info.password = g_empty_string;
|
|
g_iotx_conn_info.pub_key = g_empty_string;
|
|
|
|
*info_ptr = &g_iotx_conn_info;
|
|
}
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_REGION, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_GET_REGION, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_MQTT_DOMAIN, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_HTTP_DOMAIN, void *data);
|
|
#if defined(DYNAMIC_REGISTER)
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_DYNAMIC_REGISTER, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_GET_DYNAMIC_REGISTER, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_REGISTER_REGION, void *data);
|
|
#endif
|
|
int IOCTL_FUNC(IOTX_IOCTL_FOTA_TIMEOUT_MS, void *data);
|
|
#if defined(DEVICE_MODEL_ENABLED)
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_CUSTOMIZE_INFO, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_PROXY_REGISTER, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_OTA_DEV_ID, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_QUERY_DEVID, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_MQTT_PORT, void *);
|
|
#endif
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_AWSS_ENABLE_INTERVAL, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_AWSS_CHANNEL_SCAN_INTERVAL, void *data);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SUB_USER_TOPIC, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_RECV_PROP_REPLY, void *);
|
|
int IOCTL_FUNC(IOTX_IOCTL_SEND_PROP_SET_REPLY, void *);
|
|
|
|
int IOCTL_FUNC(IOTX_IOCTL_SET_HTTP_DOMAIN, void *data)
|
|
{
|
|
if (data == NULL)
|
|
{
|
|
return FAIL_RETURN;
|
|
}
|
|
memset(http_custom_domain, 0, strlen((char *)data) + 1);
|
|
memcpy(http_custom_domain, data, strlen((char *)data));
|
|
g_infra_http_domain[IOTX_CLOUD_REGION_CUSTOM] = (const char *)http_custom_domain;
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
int IOT_Ioctl(int option, void *data)
|
|
{
|
|
int res = FAIL_RETURN;
|
|
iotx_dev_meta_info_t *meta = NULL;
|
|
|
|
meta = &g_dev_meta_info_t;
|
|
|
|
if (option < 0 || data == NULL)
|
|
{
|
|
return FAIL_RETURN;
|
|
}
|
|
switch (option)
|
|
{
|
|
case IOTX_IOCTL_GET_MODULE:
|
|
{
|
|
if (NULL == data)
|
|
{
|
|
res = FAIL_RETURN;
|
|
break;
|
|
}
|
|
memcpy(data, meta->module, strlen(meta->module));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_MODULE:
|
|
if ((data != NULL) && (strlen(data) <= IOTX_MODULE_LEN))
|
|
{
|
|
memset(meta->module, 0, IOTX_MODULE_LEN + 1);
|
|
memcpy(meta->module, data, strlen(data));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
else
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_REGION:
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_REGION, data);
|
|
break;
|
|
case IOTX_IOCTL_GET_REGION:
|
|
res = IOCTL_FUNC(IOTX_IOCTL_GET_REGION, data);
|
|
break;
|
|
|
|
case IOTX_IOCTL_SET_MQTT_DOMAIN:
|
|
{
|
|
int domain_type = IOTX_CLOUD_REGION_CUSTOM;
|
|
IOCTL_FUNC(IOTX_IOCTL_SET_REGION, &domain_type);
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_MQTT_DOMAIN, data);
|
|
}
|
|
break;
|
|
|
|
case IOTX_IOCTL_SET_HTTP_DOMAIN:
|
|
{
|
|
int region = IOTX_HTTP_REGION_CUSTOM;
|
|
IOCTL_FUNC(IOTX_IOCTL_SET_REGION, ®ion);
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_HTTP_DOMAIN, data);
|
|
}
|
|
break;
|
|
#if defined(DYNAMIC_REGISTER)
|
|
case IOTX_IOCTL_SET_DYNAMIC_REGISTER:
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_DYNAMIC_REGISTER, data);
|
|
break;
|
|
case IOTX_IOCTL_GET_DYNAMIC_REGISTER:
|
|
res = IOCTL_FUNC(IOTX_IOCTL_GET_DYNAMIC_REGISTER, data);
|
|
break;
|
|
case IOTX_IOCTL_SET_REGISTER_REGION:
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_REGISTER_REGION, data);
|
|
break;
|
|
#endif
|
|
|
|
break;
|
|
case IOTX_IOCTL_SET_PRODUCT_KEY:
|
|
{
|
|
if ((data != NULL) && (strlen(data) <= IOTX_PRODUCT_KEY_LEN))
|
|
{
|
|
memset(meta->product_key, 0, IOTX_PRODUCT_KEY_LEN + 1);
|
|
memcpy(meta->product_key, data, strlen(data));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
else
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_GET_PRODUCT_KEY:
|
|
{
|
|
memcpy(data, meta->product_key, strlen(meta->product_key));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_PRODUCT_SECRET:
|
|
{
|
|
if ((data != NULL) && (strlen(data) <= IOTX_PRODUCT_SECRET_LEN))
|
|
{
|
|
memset(meta->product_secret, 0, IOTX_PRODUCT_SECRET_LEN + 1);
|
|
memcpy(meta->product_secret, data, strlen(data));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
else
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_GET_PRODUCT_SECRET:
|
|
{
|
|
memcpy(data, meta->product_secret, strlen(meta->product_secret));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_DEVICE_NAME:
|
|
{
|
|
if ((data != NULL) && (strlen(data) <= IOTX_DEVICE_NAME_LEN))
|
|
{
|
|
memset(meta->device_name, 0, IOTX_DEVICE_NAME_LEN + 1);
|
|
memcpy(meta->device_name, data, strlen(data));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
else
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_GET_DEVICE_NAME:
|
|
{
|
|
memcpy(data, meta->device_name, strlen(meta->device_name));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_DEVICE_SECRET:
|
|
{
|
|
if ((data != NULL) && (strlen(data) <= IOTX_DEVICE_SECRET_LEN))
|
|
{
|
|
memset(meta->device_secret, 0, IOTX_DEVICE_SECRET_LEN + 1);
|
|
memcpy(meta->device_secret, data, strlen(data));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
else
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_GET_DEVICE_SECRET:
|
|
{
|
|
memcpy(data, meta->device_secret, strlen(meta->device_secret));
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
#if defined(DEVICE_MODEL_ENABLED) && !defined(DEPRECATED_LINKKIT)
|
|
#if !defined(DEVICE_MODEL_RAWDATA_SOLO)
|
|
case IOTX_IOCTL_RECV_EVENT_REPLY:
|
|
case IOTX_IOCTL_RECV_PROP_REPLY:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_RECV_PROP_REPLY, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SEND_PROP_SET_REPLY:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SEND_PROP_SET_REPLY, data);
|
|
}
|
|
break;
|
|
#endif
|
|
#if defined(DEVICE_MODEL_GATEWAY)
|
|
#ifdef DEVICE_MODEL_SUBDEV_OTA
|
|
case IOTX_IOCTL_SET_OTA_DEV_ID:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_OTA_DEV_ID, data);
|
|
}
|
|
break;
|
|
#endif
|
|
#endif
|
|
#else
|
|
case IOTX_IOCTL_RECV_EVENT_REPLY:
|
|
case IOTX_IOCTL_RECV_PROP_REPLY:
|
|
case IOTX_IOCTL_SEND_PROP_SET_REPLY:
|
|
case IOTX_IOCTL_GET_SUBDEV_LOGIN:
|
|
{
|
|
res = SUCCESS_RETURN;
|
|
}
|
|
break;
|
|
#endif
|
|
#if defined(DEVICE_MODEL_ENABLED)
|
|
case IOTX_IOCTL_FOTA_TIMEOUT_MS:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_FOTA_TIMEOUT_MS, data);
|
|
}
|
|
break;
|
|
|
|
case IOTX_IOCTL_SUB_USER_TOPIC:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SUB_USER_TOPIC, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_CUSTOMIZE_INFO:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_CUSTOMIZE_INFO, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_MQTT_PORT:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_MQTT_PORT, data);
|
|
}
|
|
#endif
|
|
|
|
#if defined(DEVICE_MODEL_GATEWAY) && !defined(DEPRECATED_LINKKIT)
|
|
case IOTX_IOCTL_SET_PROXY_REGISTER:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_PROXY_REGISTER, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_QUERY_DEVID:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_QUERY_DEVID, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_SUBDEV_SIGN:
|
|
{
|
|
/* todo */
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_GET_SUBDEV_LOGIN:
|
|
{
|
|
/* todo */
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#if defined(WIFI_PROVISION_ENABLED)
|
|
case IOTX_IOCTL_SET_AWSS_ENABLE_INTERVAL:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_AWSS_ENABLE_INTERVAL, data);
|
|
}
|
|
break;
|
|
case IOTX_IOCTL_SET_AWSS_CHANNEL_SCAN_INTERVAL:
|
|
{
|
|
res = IOCTL_FUNC(IOTX_IOCTL_SET_AWSS_CHANNEL_SCAN_INTERVAL, data);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
{
|
|
res = FAIL_RETURN;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
void IOT_DumpMemoryStats(IOT_LogLevel level)
|
|
{
|
|
#ifdef INFRA_MEM_STATS
|
|
int lvl = (int)level;
|
|
|
|
if (lvl > LOG_DEBUG_LEVEL)
|
|
{
|
|
lvl = LOG_DEBUG_LEVEL;
|
|
HAL_Printf("Invalid input level, using default: %d => %d", level, lvl);
|
|
}
|
|
|
|
LITE_dump_malloc_free_stats(lvl);
|
|
#endif
|
|
}
|
|
|
|
static void *g_event_monitor = NULL;
|
|
|
|
int iotx_event_regist_cb(void (*monitor_cb)(int event))
|
|
{
|
|
g_event_monitor = (void *)monitor_cb;
|
|
return 0;
|
|
}
|
|
|
|
int iotx_event_post(int event)
|
|
{
|
|
if (g_event_monitor == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
((void (*)(int))g_event_monitor)(event);
|
|
return 0;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
int eventid;
|
|
void *callback;
|
|
} impl_event_map_t;
|
|
|
|
static impl_event_map_t g_impl_event_map[] = {
|
|
{ITE_AWSS_STATUS, NULL},
|
|
{ITE_CONNECT_SUCC, NULL},
|
|
{ITE_CONNECT_FAIL, NULL},
|
|
{ITE_DISCONNECTED, NULL},
|
|
{ITE_RAWDATA_ARRIVED, NULL},
|
|
{ITE_SERVICE_REQUEST, NULL},
|
|
{ITE_SERVICE_REQUEST_EXT, NULL},
|
|
{ITE_PROPERTY_SET, NULL},
|
|
{ITE_PROPERTY_GET, NULL},
|
|
#ifdef DEVICE_MODEL_SHADOW
|
|
{ITE_PROPERTY_DESIRED_GET_REPLY, NULL},
|
|
#endif
|
|
{ITE_REPORT_REPLY, NULL},
|
|
{ITE_TRIGGER_EVENT_REPLY, NULL},
|
|
{ITE_TIMESTAMP_REPLY, NULL},
|
|
{ITE_TOPOLIST_REPLY, NULL},
|
|
{ITE_PERMIT_JOIN, NULL},
|
|
{ITE_INITIALIZE_COMPLETED, NULL},
|
|
{ITE_FOTA, NULL},
|
|
{ITE_FOTA_MODULE, NULL},
|
|
{ITE_COTA, NULL},
|
|
{ITE_MQTT_CONNECT_SUCC, NULL},
|
|
{ITE_CLOUD_ERROR, NULL},
|
|
{ITE_DYNREG_DEVICE_SECRET, NULL},
|
|
{ITE_IDENTITY_RESPONSE, NULL},
|
|
{ITE_BIND_EVENT, NULL},
|
|
{ITE_STATE_EVERYTHING, NULL},
|
|
{ITE_STATE_USER_INPUT, NULL},
|
|
{ITE_STATE_SYS_DEPEND, NULL},
|
|
{ITE_STATE_MQTT_COMM, NULL},
|
|
{ITE_STATE_WIFI_PROV, NULL},
|
|
{ITE_STATE_COAP_LOCAL, NULL},
|
|
{ITE_STATE_HTTP_COMM, NULL},
|
|
{ITE_STATE_OTA, NULL},
|
|
{ITE_STATE_DEV_BIND, NULL},
|
|
{ITE_STATE_DEV_MODEL, NULL}};
|
|
|
|
void *iotx_event_callback(int evt)
|
|
{
|
|
if (evt < 0 || evt >= sizeof(g_impl_event_map) / sizeof(impl_event_map_t))
|
|
{
|
|
return NULL;
|
|
}
|
|
return g_impl_event_map[evt].callback;
|
|
}
|
|
|
|
DEFINE_EVENT_CALLBACK(ITE_AWSS_STATUS, int (*callback)(int))
|
|
DEFINE_EVENT_CALLBACK(ITE_CONNECT_SUCC, int (*callback)(void))
|
|
DEFINE_EVENT_CALLBACK(ITE_CONNECT_FAIL, int (*callback)(void))
|
|
DEFINE_EVENT_CALLBACK(ITE_DISCONNECTED, int (*callback)(void))
|
|
DEFINE_EVENT_CALLBACK(ITE_RAWDATA_ARRIVED, int (*callback)(const int, const unsigned char *, const int))
|
|
DEFINE_EVENT_CALLBACK(ITE_SERVICE_REQUEST, int (*callback)(const int, const char *, const int, const char *,
|
|
const int, char **, int *))
|
|
DEFINE_EVENT_CALLBACK(ITE_SERVICE_REQUEST_EXT, int (*callback)(int, const char *, int, const char *, int, const char *,
|
|
int, void *))
|
|
DEFINE_EVENT_CALLBACK(ITE_PROPERTY_SET, int (*callback)(const int, const char *, const int))
|
|
#ifdef DEVICE_MODEL_SHADOW
|
|
DEFINE_EVENT_CALLBACK(ITE_PROPERTY_DESIRED_GET_REPLY, int (*callback)(const char *, const int))
|
|
#endif
|
|
DEFINE_EVENT_CALLBACK(ITE_PROPERTY_GET, int (*callback)(const int, const char *, const int, char **, int *))
|
|
DEFINE_EVENT_CALLBACK(ITE_REPORT_REPLY, int (*callback)(const int, const int, const int, const char *,
|
|
const int))
|
|
DEFINE_EVENT_CALLBACK(ITE_TRIGGER_EVENT_REPLY, int (*callback)(const int, const int, const int, const char *,
|
|
const int, const char *, const int))
|
|
DEFINE_EVENT_CALLBACK(ITE_TIMESTAMP_REPLY, int (*callback)(const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_TOPOLIST_REPLY, int (*callback)(const int, const int, const int, const char *,
|
|
const int))
|
|
DEFINE_EVENT_CALLBACK(ITE_PERMIT_JOIN, int (*callback)(const char *, int))
|
|
DEFINE_EVENT_CALLBACK(ITE_INITIALIZE_COMPLETED, int (*callback)(const int))
|
|
DEFINE_EVENT_CALLBACK(ITE_FOTA, int (*callback)(const int, const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_FOTA_MODULE, int (*callback)(const int, const char *, const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_COTA, int (*callback)(const int, const char *, int, const char *,
|
|
const char *, const char *, const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_MQTT_CONNECT_SUCC, int (*callback)(void))
|
|
DEFINE_EVENT_CALLBACK(ITE_CLOUD_ERROR, int (*callback)(const int, const char *, const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_DYNREG_DEVICE_SECRET, int (*callback)(const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_IDENTITY_RESPONSE, int (*callback)(const char *))
|
|
DEFINE_EVENT_CALLBACK(ITE_BIND_EVENT, int (*callback)(const char *))
|
|
int iotx_register_for_ITE_STATE_EVERYTHING(state_handler_t callback)
|
|
{
|
|
int idx = 0;
|
|
|
|
for (idx = ITE_STATE_EVERYTHING; idx <= ITE_STATE_DEV_MODEL; idx++)
|
|
{
|
|
g_impl_event_map[idx].callback = (void *)callback;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_USER_INPUT, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_SYS_DEPEND, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_MQTT_COMM, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_WIFI_PROV, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_COAP_LOCAL, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_HTTP_COMM, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_OTA, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_DEV_BIND, state_handler_t callback)
|
|
DEFINE_EVENT_CALLBACK(ITE_STATE_DEV_MODEL, state_handler_t callback)
|
|
|
|
#if !defined(__APPLE__)
|
|
extern int vsnprintf(char *str, size_t size, const char *format, va_list ap);
|
|
#endif
|
|
|
|
#define IOTX_STATE_EVENT_MESSAGE_MAXLEN (64)
|
|
int iotx_state_event(const int event, const int code, const char *msg_format, ...)
|
|
{
|
|
char message[IOTX_STATE_EVENT_MESSAGE_MAXLEN + 1] = {0};
|
|
void *everything_state_handler = iotx_event_callback(ITE_STATE_EVERYTHING);
|
|
void *state_handler = iotx_event_callback(event);
|
|
va_list args;
|
|
|
|
if (state_handler == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (msg_format != NULL)
|
|
{
|
|
memset(message, 0, sizeof(message));
|
|
va_start(args, msg_format);
|
|
vsnprintf(message, IOTX_STATE_EVENT_MESSAGE_MAXLEN, msg_format, args);
|
|
va_end(args);
|
|
}
|
|
|
|
((state_handler_t)state_handler)(code, message);
|
|
|
|
if (everything_state_handler && everything_state_handler != state_handler)
|
|
{
|
|
((state_handler_t)everything_state_handler)(code, message);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|