static void handle_message(struct cfw_message *msg, void *param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CIRCULAR_STORAGE_PUSH_REQ:
handle_push(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_POP_REQ:
handle_pop(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_PEEK_REQ:
handle_peek(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_CLEAR_REQ:
handle_clear(msg);
break;
case MSG_ID_LL_CIRCULAR_STORAGE_SHUTDOWN_REQ:
cfw_send_message(CFW_MESSAGE_PRIV(msg));
break;
case MSG_ID_CIRCULAR_STORAGE_GET_REQ:
handle_get(msg);
default:
cfw_print_default_handle_error_msg(LOG_MODULE_MAIN,
CFW_MESSAGE_ID(
msg));
break;
}
cfw_msg_free(msg);
}
/* Handles message for test command */
static void ui_svc_tcmd_handle_message(struct cfw_message *msg, void *param)
{
int ui_status;
ui_srv_data_t *priv = CFW_MESSAGE_PRIV(msg);
struct tcmd_handler_ctx *ctx = priv->context;
char *message = balloc(BUFFER_LENGTH, NULL);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_UI_LED_RSP:
case MSG_ID_UI_VIBR_RSP:
ui_status = ((struct cfw_rsp_message *)msg)->status;
if (ui_status == DRV_RC_OK) {
TCMD_RSP_FINAL(ctx, NULL);
} else {
snprintf(message, BUFFER_LENGTH, "KO (status: %d)", ui_status);
TCMD_RSP_ERROR(ctx, message);
}
break;
default:
/* default cfw handler */
snprintf(message, BUFFER_LENGTH,
"Wrong ui_svc rsp (id: 0x%X)", CFW_MESSAGE_ID(msg));
TCMD_RSP_ERROR(ctx, message);
break;
}
cproxy_disconnect(priv->ui_service_conn);
cfw_msg_free(msg);
bfree(priv);
bfree(message);
}
static void _handle_client_message(struct cfw_message *msg, void *data)
{
(void)data;
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE:
{
/* We have passed the allocated cnx as an opaque data */
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
/* Get the service parameters from the message and store them locally */
cfw_open_conn_rsp_msg_t *con_msg = (cfw_open_conn_rsp_msg_t *)msg;
cnx->sh = (svc_client_handle_t *)(con_msg->client_handle);
cnx->src_port = con_msg->port;
cfw_msg_free(msg);
list_add(&_services, (list_t *)cnx);
break;
}
case MSG_ID_CFW_CLOSE_SERVICE:
{
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
list_remove(&_services, (list_t *)cnx);
bfree(cnx);
cfw_msg_free(msg);
break;
}
case MSG_ID_CFW_SVC_AVAIL_EVT:
{
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
if (((cfw_svc_available_evt_msg_t*)msg)->service_id == cnx->service_id) {
cfw_open_service(_proxy_handle, cnx->service_id, cnx);
}
cfw_msg_free(msg);
break;
}
default:
{
/* Find the service connection based on the message source port */
struct _svc_cnx *cnx = (struct _svc_cnx*)
list_find_first(&_services, _cmp_port, &(CFW_MESSAGE_SRC(msg)));
if (cnx) {
cnx->cb(msg, cnx->data);
} else {
cfw_msg_free(msg);
}
break;
}
}
}
static void circular_storage_shutdown(service_t *svc, struct cfw_message *msg)
{
struct cfw_message *sm = (struct cfw_message *)message_alloc(
sizeof(*sm), NULL);
/* In order to ensure that any pending requests are processed prior to the
* service shutdown, send a message to self so it will be processed after
* all other pending requests.
*/
CFW_MESSAGE_ID(sm) = MSG_ID_LL_CIRCULAR_STORAGE_SHUTDOWN_REQ;
CFW_MESSAGE_DST(sm) = circular_storage_service.port_id;
CFW_MESSAGE_SRC(sm) = circular_storage_service.port_id;
CFW_MESSAGE_PRIV(sm) = msg;
cfw_send_message(sm);
}
static void handle_ble_property_read_rsp(struct cfw_message *cfw)
{
properties_service_read_rsp_msg_t *rsp = container_of(
cfw, properties_service_read_rsp_msg_t, header);
struct ble_app_prop_rd_msg *msg = CFW_MESSAGE_PRIV(cfw);
assert(msg);
uint8_t *data = NULL;
if (rsp->status == DRV_RC_OK)
data = rsp->start_of_values;
msg->cb(data, rsp->property_size, msg->priv);
bfree(msg);
}
void test_handle_message(struct cfw_message * msg, void * param)
{
cfw_log("%s:%s for param: %s conn:%p id:%d\n", __FILE__, __func__,
(char*) param, msg->conn, CFW_MESSAGE_ID(msg));
//cfw_dump_message(msg);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
break;
case MSG_ID_CFW_SVC_AVAIL_EVT: {
int svc_id = ((cfw_svc_available_evt_msg_t *)msg)->service_id;
if (svc_id == SOC_GPIO_SERVICE_ID) {
cfw_open_service_conn(client, SOC_GPIO_SERVICE_ID, "Conn1");
}
break;
}
case MSG_ID_CFW_OPEN_SERVICE_RSP: {
cfw_log("%s:%s for conn: %s\n", __FILE__, __func__,
(char*) CFW_MESSAGE_PRIV(msg));
cfw_open_conn_rsp_msg_t * cnf = (cfw_open_conn_rsp_msg_t*) msg;
gpio_service_conn = cnf->service_conn;
gpio_configure(gpio_service_conn, 26, 1, NULL);
break;
}
case MSG_ID_GPIO_CONFIGURE_RSP:
gpio_set_state(gpio_service_conn, 26, 1, NULL);
break;
case MSG_ID_GPIO_SET_RSP: {
int val;
void * next;
if (!((int) CFW_MESSAGE_PRIV(msg))) {
val = 0;
next = (void*) 1;
} else {
val = 1;
next = (void*) 0;
}
printf("Got response: %d %d \n", val, (int) next);
if (count ++ > 100) {
cfw_close_service_conn(gpio_service_conn, NULL);
} else {
gpio_set_state(gpio_service_conn, 26, val, next);
}
}
break;
case MSG_ID_CFW_CLOSE_SERVICE_RSP: {
cfw_close_conn_rsp_msg_t * resp = (cfw_close_conn_rsp_msg_t*) msg;
cfw_log("%s: res: %d\n", __func__, resp->rsp_header.status);
exit(0);
}
break;
default: {
cfw_log("%s: Unhandled message: %d\n", __func__, CFW_MESSAGE_ID(msg));
break;
}
}
cfw_msg_free(msg);
}
void client_handle_message(struct cfw_message *msg, void *param)
{
_cfw_client_t *c = (_cfw_client_t *)param;
bool handled = false;
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
if (get_conn_helper(c, msg->priv))
handled = true;
break;
case MSG_ID_CFW_SVC_AVAIL_EVT:
{
cfw_svc_available_evt_msg_t *evt =
(cfw_svc_available_evt_msg_t *)msg;
if (get_conn_helper(c, evt->header.priv)) {
cfw_open_service_conn(c, evt->service_id,
evt->header.priv);
handled = true;
}
}
break;
case MSG_ID_CFW_OPEN_SERVICE_RSP:
{
cfw_open_conn_rsp_msg_t *cnf = (cfw_open_conn_rsp_msg_t *)msg;
/** Make client handle point to server handle */
((cfw_service_conn_t *)cnf->service_conn)->server_handle =
cnf->svc_server_handle;
/** Initialize service port. */
((cfw_service_conn_t *)cnf->service_conn)->port = cnf->port;
#ifndef CONFIG_PORT_IS_MASTER
/* Set local port and cpu id */
if (get_cpu_id() != cnf->cpu_id) {
port_set_port_id(cnf->port);
port_set_cpu_id(cnf->port, cnf->cpu_id);
}
#endif
struct conn_helper_data *helper = get_conn_helper(
c, cnf->header.priv);
if (helper != NULL) {
helper->service_conn =
(cfw_service_conn_t *)cnf->service_conn;
if (helper->event_count > 0) {
cfw_register_events(helper->service_conn,
helper->events,
helper->event_count,
helper);
} else {
/* call the helper callback and free it */
cfw_open_service_helper_done(c, helper);
}
handled = true;
}
break;
}
case MSG_ID_CFW_REGISTER_EVT_RSP:
{
struct conn_helper_data *helper = get_conn_helper(
c, CFW_MESSAGE_PRIV(msg));
if (helper != NULL) {
helper->cb(helper->service_conn, helper->cb_data);
list_remove(&c->helper_list, &helper->list);
bfree(helper);
handled = true;
}
}
break;
case MSG_ID_CFW_CLOSE_SERVICE_RSP:
{
/* Free client-side conn */
bfree(msg->conn);
break;
}
default:
//Nothing to do
break;
}
if (handled)
/* message handled here: free it */
bfree(msg);
else {
/* defer processing to message handler */
if (CFW_MESSAGE_CB(msg)) {
/* A specific callback was specified for this message */
CFW_MESSAGE_CB(msg) (msg);
} else {
/* Call client global message handler */
c->handle_msg(msg, c->data);
}
}
}
