void tImgLinear::reset() {
if( _data != nullptr ) {
free_data_buffer();
}
_size = tSize();
}
void tImgLinear::alloc_data_buffer() {
if( _data != nullptr ) {
free_data_buffer();
}
size_t s = size().y() * pitch();
uint8_t* p = static_cast<uint8_t*>( rlf::rimg_alloc_raw_data::alloc_raw_data( s ) );
// t_Img_template<uint8_t>::set_data((uint8_t *) GlobalAlloc(GMEM_FIXED, s) );
set_data( p );
_is_allocated = true;
}
connector_status_t connector_step(connector_handle_t const handle)
{
connector_status_t result = connector_init_error;
connector_data_t * const connector_ptr = handle;
ASSERT_GOTO(handle != NULL, done);
if (connector_ptr->signature != connector_signature) goto done;
switch (connector_ptr->stop.state)
{
case connector_state_running:
break;
case connector_state_stop_by_initiate_action:
if (is_connector_stopped(connector_ptr, connector_close_status_device_stopped))
{
result = connector_stop_callback(connector_ptr, connector_transport_all, connector_ptr->stop.user_context);
if (result == connector_abort)
{
goto error;
}
else if (result == connector_working)
{
connector_ptr->stop.state = connector_state_running;
}
}
break;
case connector_state_abort_by_callback:
case connector_state_terminate_by_initiate_action:
if (is_connector_stopped(connector_ptr, connector_close_status_device_terminated))
{
connector_ptr->connector_got_device_id = connector_false; /* TODO, Probably this should not be done with provisioning! */
connector_ptr->signature = NULL;
result = (connector_ptr->stop.state == connector_state_terminate_by_initiate_action) ? connector_device_terminated : connector_abort; /* ETHERIOS-EGEAR-MOD */
free_data_buffer(connector_ptr, named_buffer_id(connector_data), connector_ptr);
connector_debug_printf("connector_step: free Cloud Connector\n");
goto done;
}
break;
default:
break;
}
#if (CONNECTOR_TRANSPORT_COUNT == 1)
#if (defined CONNECTOR_TRANSPORT_TCP)
result = connector_edp_step(connector_ptr);
#endif
#if (defined CONNECTOR_TRANSPORT_UDP)
result = connector_udp_step(connector_ptr);
#endif
#if (defined CONNECTOR_TRANSPORT_SMS)
result = connector_sms_step(connector_ptr);
#endif
#else
{
#define next_network(current_network) (((current_network) == last_network_index) ? first_network_index : (connector_network_type_t) ((current_network) + 1))
connector_network_type_t const first_network_index = (connector_network_type_t) 0;
connector_network_type_t const last_network_index = (connector_network_type_t) (connector_network_count - 1);
connector_network_type_t const first_network_checked = connector_ptr->first_running_network;
connector_network_type_t current_network = first_network_checked;
do
{
connector_status_t (*step_func)(connector_data_t * const connector_ptr);
switch (current_network)
{
#if (defined CONNECTOR_TRANSPORT_TCP)
case connector_network_tcp: step_func = connector_edp_step; break;
#endif
#if (defined CONNECTOR_TRANSPORT_UDP)
case connector_network_udp: step_func = connector_udp_step; break;
#endif
#if (defined CONNECTOR_TRANSPORT_SMS)
case connector_network_sms: step_func = connector_sms_step; break;
#endif
default:
ASSERT(connector_false);
result = connector_abort;
goto error; break;
}
result = step_func(connector_ptr);
current_network = next_network(current_network);
} while ((current_network != first_network_checked) && (result == connector_idle));
connector_ptr->first_running_network = (result == connector_idle) ? next_network(first_network_checked): current_network;
#undef next_network
}
#endif
error:
switch (result)
{
case connector_abort:
abort_connector(connector_ptr);
/* no break; */
case connector_device_terminated:
result = connector_working;
break;
default:
break;
}
done:
return result;
}
connector_handle_t connector_init(connector_callback_t const callback)
{
connector_data_t * connector_handle = NULL;
connector_status_t status;
#if (defined CONNECTOR_SW_DESCRIPTION)
connector_debug_printf("Cloud Connector v%s %s\n", CONNECTOR_SW_VERSION, CONNECTOR_SW_DESCRIPTION);
#else
connector_debug_printf("Cloud Connector v%s\n", CONNECTOR_SW_VERSION);
#endif
{
void * handle;
#if (defined CONNECTOR_NO_MALLOC)
status = malloc_data_buffer(NULL, sizeof *connector_handle, named_buffer_id(connector_data), &handle);
#else
status = malloc_cb(callback, sizeof *connector_handle, &handle);
#endif
COND_ELSE_GOTO(status == connector_working, done);
memset(handle, 0x00, sizeof *connector_handle); /* Init structure, all pointers to NULL */
connector_handle = handle;
}
connector_handle->callback = callback;
status = manage_device_id(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
/* make a copy of the cloud url */
#if (defined CONNECTOR_TRANSPORT_TCP) || (defined CONNECTOR_TRANSPORT_UDP)
#if (defined CONNECTOR_CLOUD_URL)
{
static char const connector_device_cloud_url[]= CONNECTOR_CLOUD_URL;
connector_handle->device_cloud_url = (char *)connector_device_cloud_url;
connector_handle->device_cloud_url_length = sizeof connector_device_cloud_url -1;
}
#else
status = get_config_device_cloud_url(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
#endif
#endif /* (defined CONNECTOR_TRANSPORT_TCP) || (defined CONNECTOR_TRANSPORT_UDP) */
/* make a copy of the cloud phone */
#if (defined CONNECTOR_TRANSPORT_SMS)
#if (defined CONNECTOR_CLOUD_PHONE)
{
static char const connector_device_cloud_phone[]= CONNECTOR_CLOUD_PHONE;
connector_handle->device_cloud_phone = (char *)connector_device_cloud_phone;
connector_handle->device_cloud_phone_length = sizeof connector_device_cloud_phone -1;
}
#else
status = get_config_device_cloud_phone(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
#endif
#if (defined CONNECTOR_CLOUD_SERVICE_ID)
{
static char const connector_device_cloud_service_id[]= CONNECTOR_CLOUD_SERVICE_ID;
connector_handle->device_cloud_service_id = (char *)connector_device_cloud_service_id;
connector_handle->device_cloud_service_id_length = sizeof connector_device_cloud_service_id -1;
}
#else
status = get_config_device_cloud_service_id(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
#endif
#endif /* (defined CONNECTOR_TRANSPORT_SMS) */
#if (defined CONNECTOR_TRANSPORT_TCP)
status = connector_edp_init(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
#endif
#if (defined CONNECTOR_TRANSPORT_UDP) || (defined CONNECTOR_TRANSPORT_SMS)
status = connector_sm_init(connector_handle);
COND_ELSE_GOTO(status == connector_working, error);
#endif
#if (defined CONNECTOR_TRANSPORT_COUNT > 1)
connector_handle->first_running_network = (connector_network_type_t) 0;
#endif
connector_handle->signature = connector_signature;
goto done;
error:
free_data_buffer(connector_handle, named_buffer_id(connector_data), connector_handle);
connector_handle = NULL;
done:
return connector_handle;
}
