[PATCH v2 09/11] stk: Add support of the Setup event list proactive command

[Philippe Nunes <philippe.nunes@linux.intel.com>]

[-- Attachment #1: Type: text/plain, Size: 6528 bytes --]

---
 src/stk.c |  120 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 110 insertions(+), 10 deletions(-)

diff --git a/src/stk.c b/src/stk.c
index 1e5869a..4c81bf8 100644
--- a/src/stk.c
+++ b/src/stk.c
@@ -90,6 +90,8 @@ struct ofono_stk {
 		gsize rx_remaining;
 		gsize tx_avail;
 		gboolean link_on_demand;
+		gboolean report_data_available;
+		gboolean report_channel_status;
 		struct ofono_gprs *gprs;
 		struct stk_bearer_description bearer_desc;
 		enum stk_transport_protocol_type protocol;
@@ -519,6 +521,61 @@ static void cancel_pending_dtmf(struct ofono_stk *stk)
 		__ofono_voicecall_tone_cancel(vc, stk->dtmf_id);
 }
 
+static void event_download_envelope_cb(struct ofono_stk *stk, gboolean ok,
+				const unsigned char *data, int len)
+{
+	if (!ok) {
+		ofono_error("Event download to UICC failed");
+		return;
+	}
+
+	if (len)
+		ofono_error("Event download returned %i bytes of data",
+				len);
+
+	DBG("Event download  to UICC reported no error");
+}
+
+static void stk_send_channel_status_event(struct ofono_stk *stk)
+{
+	struct stk_envelope e;
+
+	memset(&e, 0, sizeof(e));
+	e.type = STK_ENVELOPE_TYPE_EVENT_DOWNLOAD;
+	e.src = STK_DEVICE_IDENTITY_TYPE_TERMINAL;
+	e.event_download.type = STK_EVENT_TYPE_CHANNEL_STATUS;
+	e.event_download.channel_status.channel.id = stk->bip.channel.id;
+	e.event_download.channel_status.channel.status =
+						stk->bip.channel.status;
+
+	if (stk->bip.channel.status ==
+				STK_CHANNEL_PACKET_DATA_SERVICE_ACTIVATED)
+		memcpy(&e.event_download.channel_status.bearer_desc,
+				&stk->bip.bearer_desc,
+				sizeof(struct stk_bearer_description));
+
+	if (stk_send_envelope(stk, &e, event_download_envelope_cb, 0))
+		event_download_envelope_cb(stk, FALSE, NULL, -1);
+}
+
+static void stk_send_data_available_event(struct ofono_stk *stk,
+						unsigned short data_available)
+{
+	struct stk_envelope e;
+
+	memset(&e, 0, sizeof(e));
+	e.type = STK_ENVELOPE_TYPE_EVENT_DOWNLOAD;
+	e.src = STK_DEVICE_IDENTITY_TYPE_TERMINAL;
+	e.event_download.type = STK_EVENT_TYPE_DATA_AVAILABLE;
+	e.event_download.data_available.channel.id = stk->bip.channel.id;
+	e.event_download.data_available.channel.status =
+						stk->bip.channel.status;
+	e.event_download.data_available.channel_data_len = data_available;
+
+	if (stk_send_envelope(stk, &e, event_download_envelope_cb, 0))
+		event_download_envelope_cb(stk, FALSE, NULL, -1);
+}
+
 static void ofono_stk_deactivate_context_cb(int error, void *data)
 {
 	struct ofono_stk *stk = data;
@@ -534,8 +591,10 @@ static void ofono_stk_deactivate_context_cb(int error, void *data)
 			send_simple_response(stk, STK_RESULT_TYPE_NOT_CAPABLE);
 		else
 			send_simple_response(stk, STK_RESULT_TYPE_SUCCESS);
-	} else {
-		/* TODO send channel status event */
+	} else if (stk->bip.report_channel_status) {
+		/* user cancellation */
+		stk->bip.channel.status = STK_CHANNEL_LINK_DROPPED;
+		stk_send_channel_status_event(stk);
 	}
 
 	stk->bip.channel.id = 0;
@@ -672,11 +731,10 @@ static gboolean receive_callback(GIOChannel *channel, GIOCondition cond,
 		ioctl(fd, FIONREAD, &len);
 		DBG("%zd bytes to read", len);
 
-		/*
-		 * TODO
-		 * send data available event if the buffer is empty
-		 * when new data arrives in it
-		 */
+		if (len > 0 && stk->bip.rx_remaining == 0 &&
+				stk->bip.report_data_available) {
+			stk_send_data_available_event(stk, len);
+		}
 
 		stk->bip.rx_remaining = len;
 
@@ -711,7 +769,8 @@ static void ofono_stk_activate_context_cb(int error, const char *interface,
 				STK_COMMAND_TYPE_OPEN_CHANNEL &&
 				stk->pending_cmd->type !=
 				STK_COMMAND_TYPE_SEND_DATA)) {
-			/* TODO send channel status event */
+			if (stk->bip.report_channel_status)
+				stk_send_channel_status_event(stk);
 			return;
 		} else {
 			rsp.result.type = STK_RESULT_TYPE_NETWORK_UNAVAILABLE;
@@ -805,7 +864,8 @@ static void ofono_stk_activate_context_cb(int error, const char *interface,
 	g_io_channel_unref(io);
 
 	if (stk->pending_cmd == NULL) {
-		/* TODO send channel status event */
+		if (stk->bip.report_channel_status)
+			stk_send_channel_status_event(stk);
 		return;
 	} else if (stk->pending_cmd->type == STK_COMMAND_TYPE_OPEN_CHANNEL) {
 		rsp.open_channel.channel.id = stk->bip.channel.id;
@@ -828,7 +888,8 @@ static void ofono_stk_activate_context_cb(int error, const char *interface,
 		}
 		rsp.send_data.tx_avail = stk->bip.tx_avail;
 	} else {
-		/* TODO send channel status event */
+		if (stk->bip.report_channel_status)
+			stk_send_channel_status_event(stk);
 		return;
 	}
 
@@ -2747,6 +2808,8 @@ static gboolean handle_command_refresh(const struct stk_command *cmd,
 		case 5:
 		case 6:
 			free_idle_mode_text(stk);
+			stk->bip.report_data_available = FALSE;
+			stk->bip.report_channel_status = FALSE;
 			__ofono_sim_refresh(sim, file_list, FALSE, TRUE);
 			break;
 		}
@@ -3355,6 +3418,38 @@ static gboolean handle_command_get_channel_status(const struct stk_command *cmd,
 	return TRUE;
 }
 
+static gboolean handle_command_setup_event_list(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	const struct stk_command_setup_event_list *sel = &cmd->setup_event_list;
+	unsigned int i;
+
+	stk->bip.report_data_available = FALSE;
+	stk->bip.report_channel_status = FALSE;
+
+	for (i = 0; i < sel->event_list.len; i++) {
+		switch (sel->event_list.list[i]) {
+		case STK_EVENT_TYPE_DATA_AVAILABLE:
+			DBG("Enable data available event");
+			stk->bip.report_data_available = TRUE;
+			break;
+		case STK_EVENT_TYPE_CHANNEL_STATUS:
+			DBG("Enable channel status event");
+			stk->bip.report_channel_status = TRUE;
+			break;
+		default:
+			DBG("Event type (%d) not supported",
+						sel->event_list.list[i]);
+			rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+			return TRUE;
+		}
+	}
+
+	rsp->result.type = STK_RESULT_TYPE_SUCCESS;
+	return TRUE;
+}
+
 static void stk_proactive_command_cancel(struct ofono_stk *stk)
 {
 	if (stk->immediate_response)
@@ -3573,6 +3668,11 @@ void ofono_stk_proactive_command_notify(struct ofono_stk *stk,
 							&rsp, stk);
 		break;
 
+	case STK_COMMAND_TYPE_SETUP_EVENT_LIST:
+		respond = handle_command_setup_event_list(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
 	default:
 		rsp.result.type = STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD;
 		break;
-- 
1.7.1