[PATCH 1/3] stkagent: Add ConfirmCallSetup request.

[PATCH 1/3] stkagent: Add ConfirmCallSetup request.

[Andrzej Zaborowski]

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

---
 src/stkagent.c |   65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/stkagent.h |    5 ++++
 2 files changed, 70 insertions(+), 0 deletions(-)

diff --git a/src/stkagent.c b/src/stkagent.c
index e71436d..f62c2bd 100644
--- a/src/stkagent.c
+++ b/src/stkagent.c
@@ -789,3 +789,68 @@ int stk_agent_request_input(struct stk_agent *agent, const char *text,
 
 	return 0;
 }
+
+static void confirm_call_cb(DBusPendingCall *call, void *data)
+{
+	struct stk_agent *agent = data;
+	stk_agent_confirmation_cb cb = agent->user_cb;
+	DBusMessage *reply = dbus_pending_call_steal_reply(call);
+	enum stk_agent_result result;
+	gboolean remove_agent;
+	dbus_bool_t confirm;
+
+	if (check_error(agent, reply,
+			ALLOWED_ERROR_TERMINATE, &result) == -EINVAL) {
+		remove_agent = TRUE;
+		goto error;
+	}
+
+	if (result != STK_AGENT_RESULT_OK) {
+		cb(result, FALSE, agent->user_data);
+		goto done;
+	}
+
+	if (dbus_message_get_args(reply, NULL,
+					DBUS_TYPE_BOOLEAN, &confirm,
+					DBUS_TYPE_INVALID) == FALSE) {
+		ofono_error("Can't parse the reply to ConfirmCallSetup()");
+		remove_agent = TRUE;
+		goto error;
+	}
+
+	cb(result, confirm, agent->user_data);
+
+	CALLBACK_END();
+}
+
+int stk_agent_confirm_call(struct stk_agent *agent, const char *text,
+				uint8_t icon_id, stk_agent_confirmation_cb cb,
+				void *user_data, ofono_destroy_func destroy,
+				int timeout)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+
+	agent->msg = dbus_message_new_method_call(agent->bus, agent->path,
+							OFONO_SIM_APP_INTERFACE,
+							"ConfirmCallSetup");
+	if (agent->msg == NULL)
+		return -ENOMEM;
+
+	dbus_message_append_args(agent->msg,
+					DBUS_TYPE_STRING, &text,
+					DBUS_TYPE_BYTE, &icon_id,
+					DBUS_TYPE_INVALID);
+
+	if (dbus_connection_send_with_reply(conn, agent->msg, &agent->call,
+						timeout) == FALSE ||
+			agent->call == NULL)
+		return -EIO;
+
+	agent->user_cb = cb;
+	agent->user_data = user_data;
+	agent->user_destroy = destroy;
+
+	dbus_pending_call_set_notify(agent->call, confirm_call_cb, agent, NULL);
+
+	return 0;
+}
diff --git a/src/stkagent.h b/src/stkagent.h
index 70f1f88..c644210 100644
--- a/src/stkagent.h
+++ b/src/stkagent.h
@@ -112,5 +112,10 @@ int stk_agent_request_input(struct stk_agent *agent, const char *text,
 				void *user_data, ofono_destroy_func destroy,
 				int timeout);
 
+int stk_agent_confirm_call(struct stk_agent *agent, const char *text,
+				uint8_t icon_id, stk_agent_confirmation_cb cb,
+				void *user_data, ofono_destroy_func destroy,
+				int timeout);
+
 void append_menu_items_variant(DBusMessageIter *iter,
 				const struct stk_menu_item *items);
-- 
1.7.1.86.g0e460.dirty

[PATCH 2/3][RfC] Add __ofono_voicecall_dial for other atoms to make calls.

[Andrzej Zaborowski]

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

The callback is only invoked when the call is CONNECTED (becomes
active).  Cancel ensures that the callback will not be called and
does nothing more in this version, it's an open question if we
want to release the call.
---
 src/ofono.h     |   19 ++++-
 src/voicecall.c |  247 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 265 insertions(+), 1 deletions(-)

diff --git a/src/ofono.h b/src/ofono.h
index 4a42f0c..656d0d7 100644
--- a/src/ofono.h
+++ b/src/ofono.h
@@ -169,11 +169,28 @@ void __ofono_atom_free(struct ofono_atom *atom);
 #include <ofono/cbs.h>
 #include <ofono/devinfo.h>
 #include <ofono/phonebook.h>
-#include <ofono/voicecall.h>
 #include <ofono/gprs.h>
 #include <ofono/gprs-context.h>
 #include <ofono/radio-settings.h>
 
+#include <ofono/voicecall.h>
+
+enum ofono_voicecall_interaction {
+	OFONO_VOICECALL_INTERACTION_NONE	= 0,
+	OFONO_VOICECALL_INTERACTION_PUT_ON_HOLD	= 1,
+	OFONO_VOICECALL_INTERACTION_DISCONNECT	= 2,
+};
+
+typedef void (*ofono_voicecall_dial_cb_t)(struct ofono_call *call, void *data);
+
+ofono_bool_t __ofono_voicecall_busy(struct ofono_voicecall *vc);
+int __ofono_voicecall_dial(struct ofono_voicecall *vc,
+				const char *addr, int addr_type,
+				const char *message, unsigned char icon_id,
+				enum ofono_voicecall_interaction interaction,
+				ofono_voicecall_dial_cb_t cb, void *user_data);
+void __ofono_voicecall_dial_cancel(struct ofono_voicecall *vc);
+
 #include <ofono/sms.h>
 
 struct sms;
diff --git a/src/voicecall.c b/src/voicecall.c
index 4b4d314..fb0c515 100644
--- a/src/voicecall.c
+++ b/src/voicecall.c
@@ -27,6 +27,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <errno.h>
+#include <stdint.h>
 
 #include <glib.h>
 #include <gdbus.h>
@@ -59,6 +60,7 @@ struct ofono_voicecall {
 	const struct ofono_voicecall_driver *driver;
 	void *driver_data;
 	struct ofono_atom *atom;
+	struct dial_request *dial_req;
 };
 
 struct voicecall {
@@ -66,6 +68,19 @@ struct voicecall {
 	struct ofono_voicecall *vc;
 	time_t start_time;
 	time_t detect_time;
+	const char *message;
+	uint8_t icon_id;
+};
+
+struct dial_request {
+	struct ofono_voicecall *vc;
+	const char *message;
+	uint8_t icon_id;
+	enum ofono_voicecall_interaction interaction;
+	ofono_voicecall_dial_cb_t cb;
+	void *user_data;
+	struct voicecall *call;
+	struct ofono_phone_number ph;
 };
 
 static const char *default_en_list[] = { "911", "112", NULL };
@@ -243,6 +258,14 @@ static DBusMessage *voicecall_get_properties(DBusConnection *conn,
 					&timestr);
 	}
 
+	if (v->message)
+		ofono_dbus_dict_append(&dict, "Information", DBUS_TYPE_STRING,
+					&v->message);
+
+	if (v->icon_id)
+		ofono_dbus_dict_append(&dict, "Icon", DBUS_TYPE_BYTE,
+					&v->icon_id);
+
 	dbus_message_iter_close_container(&iter, &dict);
 
 	return reply;
@@ -504,6 +527,32 @@ static void voicecall_set_call_status(struct voicecall *call,
 						OFONO_VOICECALL_INTERFACE,
 						"StartTime", DBUS_TYPE_STRING,
 						&timestr);
+
+		if (call->vc->dial_req && call == call->vc->dial_req->call) {
+			struct dial_request *req = call->vc->dial_req;
+
+			if (req->cb)
+				req->cb(call->call, req->user_data);
+
+			/*
+			 * TODO: parse the called number for DTMF tones to be
+			 * sent after call becomes active, and send them.
+			 */
+
+			call->vc->dial_req = NULL;
+			g_free(req);
+		}
+	}
+
+	if (status == CALL_STATUS_DISCONNECTED && call->vc->dial_req &&
+			call == call->vc->dial_req->call) {
+		struct dial_request *req = call->vc->dial_req;
+
+		if (req->cb)
+			req->cb(NULL, req->user_data);
+
+		call->vc->dial_req = NULL;
+		g_free(req);
 	}
 }
 
@@ -2020,3 +2069,201 @@ int ofono_voicecall_get_next_callid(struct ofono_voicecall *vc)
 
 	return __ofono_modem_callid_next(modem);
 }
+
+ofono_bool_t __ofono_voicecall_busy(struct ofono_voicecall *vc)
+{
+	return vc->dial_req || vc->pending || voicecalls_have_active(vc) ||
+			g_slist_length(vc->call_list) >= MAX_VOICE_CALLS ||
+			voicecalls_have_incoming(vc) ||
+			voicecalls_num_connecting(vc) > 0;
+}
+
+static void dial_request_cb(const struct ofono_error *error, void *data)
+{
+	struct ofono_voicecall *vc = data;
+	GSList *l;
+	struct voicecall *v = NULL;
+	gboolean need_to_emit = FALSE;
+
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		DBG("Dial callback returned error: %s",
+			telephony_error_to_str(error));
+
+		goto done;
+	}
+
+	/* Two things can happen, the call notification arrived before dial
+	 * callback or dial callback was first.	Handle here */
+	for (l = vc->call_list; l; l = l->next) {
+		v = l->data;
+
+		if (v->call->status == CALL_STATUS_DIALING ||
+				v->call->status == CALL_STATUS_ALERTING ||
+				v->call->status == CALL_STATUS_ACTIVE)
+			break;
+	}
+
+	if (!l) {
+		struct ofono_call *call =
+			synthesize_outgoing_call(vc, vc->pending);
+		if (!call) {
+			v = NULL;
+
+			goto done;
+		}
+
+		v = voicecall_create(vc, call);
+		if (!v)
+			goto done;
+
+		v->detect_time = time(NULL);
+
+		DBG("Registering new call: %d", call->id);
+		voicecall_dbus_register(v);
+
+		vc->call_list = g_slist_insert_sorted(vc->call_list, v,
+					call_compare);
+
+		need_to_emit = TRUE;
+	}
+
+	v->message = vc->dial_req->message;
+	v->icon_id = vc->dial_req->icon_id;
+
+	if (need_to_emit)
+		emit_call_list_changed(vc);
+
+done:
+	if (vc->dial_req->cb) {
+		if (v && v->call->status != CALL_STATUS_ACTIVE) {
+			vc->dial_req->call = v;
+
+			/* Wait for the call connected message */
+			return;
+		}
+
+		vc->dial_req->cb(v ? v->call : NULL, vc->dial_req->user_data);
+	}
+
+	g_free(vc->dial_req);
+	vc->dial_req = NULL;
+}
+
+static int dial_request(struct ofono_voicecall *vc)
+{
+	if (g_slist_length(vc->call_list) >= MAX_VOICE_CALLS ||
+			voicecalls_have_incoming(vc) ||
+			voicecalls_num_connecting(vc) > 0 ||
+			vc->pending) {
+		g_free(vc->dial_req);
+		vc->dial_req = NULL;
+
+		return -EBUSY;
+	}
+
+	vc->driver->dial(vc, &vc->dial_req->ph, OFONO_CLIR_OPTION_DEFAULT,
+				OFONO_CUG_OPTION_DEFAULT, dial_request_cb, vc);
+
+	return 0;
+}
+
+static void hold_or_disconnect_cb(const struct ofono_error *error, void *data)
+{
+	struct ofono_voicecall *vc = data;
+	ofono_voicecall_dial_cb_t cb = vc->dial_req->cb;
+	void *user_data = vc->dial_req->user_data;
+	int err;
+
+	if (!cb) {
+		g_free(vc->dial_req);
+		vc->dial_req = NULL;
+
+		return;
+	}
+
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		cb(FALSE, user_data);
+
+		g_free(vc->dial_req);
+		vc->dial_req = NULL;
+
+		return;
+	}
+
+	err = dial_request(vc);
+
+	if (err < 0)
+		cb(FALSE, user_data);
+}
+
+int __ofono_voicecall_dial(struct ofono_voicecall *vc,
+				const char *addr, int addr_type,
+				const char *message, unsigned char icon_id,
+				enum ofono_voicecall_interaction interaction,
+				ofono_voicecall_dial_cb_t cb, void *user_data)
+{
+	struct dial_request *req;
+
+	if (!valid_phone_number_format(addr))
+		return -EINVAL;
+
+	if (!vc->driver->dial)
+		return -ENOSYS;
+
+	/*
+	 * TODO: if addr starts with "112", possibly translate into the
+	 * technology-specific emergency number.
+	 */
+
+	req = g_try_new0(struct dial_request, 1);
+	req->message = message;
+	req->icon_id = icon_id;
+	req->interaction = interaction;
+	req->cb = cb;
+	req->user_data = user_data;
+
+	/* TODO: parse the tones to dial after call connected */
+	req->ph.type = addr_type;
+	strncpy(req->ph.number, addr, 20);
+
+	if (!voicecalls_have_active(vc)) {
+		vc->dial_req = req;
+
+		return dial_request(vc);
+	}
+
+	switch (interaction) {
+	case OFONO_VOICECALL_INTERACTION_NONE:
+		return -EBUSY;
+
+	case OFONO_VOICECALL_INTERACTION_PUT_ON_HOLD:
+		/* Note: dialling automatically puts active calls on hold */
+		vc->dial_req = req;
+
+		return dial_request(vc);
+
+	case OFONO_VOICECALL_INTERACTION_DISCONNECT:
+		if (!vc->driver->release_all_active) {
+			g_free(req);
+
+			return -ENOSYS;
+		}
+
+		vc->driver->release_all_active(vc, hold_or_disconnect_cb, vc);
+		break;
+	}
+
+	vc->dial_req = req;
+
+	return 0;
+}
+
+void __ofono_voicecall_dial_cancel(struct ofono_voicecall *vc)
+{
+	if (!vc->dial_req || !vc->dial_req->cb)
+		return;
+
+	vc->dial_req->cb = NULL;
+
+	/* If vc->dial_req->call is set, try to release it? */
+}
-- 
1.7.1.86.g0e460.dirty

[PATCH 3/3] stk: Handle the Set Up Call proactive command.

[Andrzej Zaborowski]

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

---
 src/stk.c |  198 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 198 insertions(+), 0 deletions(-)

diff --git a/src/stk.c b/src/stk.c
index f391396..f0ca9b7 100644
--- a/src/stk.c
+++ b/src/stk.c
@@ -1399,6 +1399,198 @@ static gboolean handle_command_get_input(const struct stk_command *cmd,
 	return FALSE;
 }
 
+static void call_setup_connected(struct ofono_call *call, void *data)
+{
+	struct ofono_stk *stk = data;
+	struct stk_response rsp;
+	static struct ofono_error error = { .type = OFONO_ERROR_TYPE_FAILURE };
+	static unsigned char facility_rejected_result[] = { 0x9d };
+
+	if (!call) {
+		memset(&rsp, 0, sizeof(rsp));
+
+		rsp.result.type = STK_RESULT_TYPE_NETWORK_UNAVAILABLE;
+		rsp.result.additional_len = sizeof(facility_rejected_result);
+		rsp.result.additional = facility_rejected_result;
+
+		if (stk_respond(stk, &rsp, stk_command_cb))
+			stk_command_cb(&error, stk);
+
+		return;
+	}
+
+	if (call->status == CALL_STATUS_ACTIVE)
+		send_simple_response(stk, STK_RESULT_TYPE_SUCCESS);
+	else
+		send_simple_response(stk, STK_RESULT_TYPE_USER_CANCEL);
+}
+
+static void call_setup_cancel(struct ofono_stk *stk)
+{
+	struct ofono_voicecall *vc;
+	struct ofono_atom *vc_atom;
+
+	vc_atom = __ofono_modem_find_atom(__ofono_atom_get_modem(stk->atom),
+						OFONO_ATOM_TYPE_VOICECALL);
+	if (!vc_atom)
+		return;
+
+	vc = __ofono_atom_get_data(vc_atom);
+	if (vc)
+		__ofono_voicecall_dial_cancel(vc);
+}
+
+static void confirm_call_cb(enum stk_agent_result result, gboolean confirm,
+				void *user_data)
+{
+	struct ofono_stk *stk = user_data;
+	static struct ofono_error error = { .type = OFONO_ERROR_TYPE_FAILURE };
+	const struct stk_command_setup_call *sc = &stk->pending_cmd->setup_call;
+	uint8_t qualifier = stk->pending_cmd->qualifier;
+	static unsigned char busy_on_call_result[] = { 0x02 };
+	static unsigned char no_cause_result[] = { 0x00 };
+	struct ofono_voicecall *vc = NULL;
+	struct ofono_atom *vc_atom;
+	struct stk_response rsp;
+	int err;
+
+	switch (result) {
+	case STK_AGENT_RESULT_TIMEOUT:
+		confirm = FALSE;
+		/* Fall through */
+
+	case STK_AGENT_RESULT_OK:
+		if (confirm)
+			break;
+
+		send_simple_response(stk, STK_RESULT_TYPE_USER_REJECT);
+		return;
+
+	case STK_AGENT_RESULT_TERMINATE:
+	default:
+		send_simple_response(stk, STK_RESULT_TYPE_USER_TERMINATED);
+		return;
+	}
+
+	vc_atom = __ofono_modem_find_atom(__ofono_atom_get_modem(stk->atom),
+						OFONO_ATOM_TYPE_VOICECALL);
+	if (vc_atom)
+		vc = __ofono_atom_get_data(vc_atom);
+
+	if (!vc) {
+		send_simple_response(stk, STK_RESULT_TYPE_NOT_CAPABLE);
+		return;
+	}
+
+	/*
+	 * The terminal may have become busy while we were waiting for
+	 * user confirmation.
+	 */
+	if (__ofono_voicecall_busy(vc) && (qualifier == 0 || qualifier == 1)) {
+		memset(&rsp, 0, sizeof(rsp));
+
+		rsp.result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+		rsp.result.additional_len = sizeof(busy_on_call_result);
+		rsp.result.additional = busy_on_call_result;
+
+		if (stk_respond(stk, &rsp, stk_command_cb))
+			stk_command_cb(&error, stk);
+
+		return;
+	}
+
+	err = __ofono_voicecall_dial(vc, sc->addr.number, sc->addr.ton_npi,
+					sc->alpha_id_call_setup, 0,
+					qualifier >> 1, call_setup_connected,
+					stk);
+	if (err >= 0) {
+		stk->cancel_cmd = call_setup_cancel;
+
+		return;
+	}
+
+	if (err == -EBUSY) {
+		send_simple_response(stk, STK_RESULT_TYPE_TERMINAL_BUSY);
+
+		return;
+	}
+
+	if (err == -ENOSYS) {
+		send_simple_response(stk, STK_RESULT_TYPE_NOT_CAPABLE);
+
+		return;
+	}
+
+	memset(&rsp, 0, sizeof(rsp));
+
+	rsp.result.type = STK_RESULT_TYPE_NETWORK_UNAVAILABLE;
+	rsp.result.additional_len = sizeof(no_cause_result);
+	rsp.result.additional = no_cause_result;
+
+	if (stk_respond(stk, &rsp, stk_command_cb))
+		stk_command_cb(&error, stk);
+}
+
+static gboolean handle_command_set_up_call(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	const struct stk_command_setup_call *sc = &cmd->setup_call;
+	uint8_t qualifier = cmd->qualifier;
+	static unsigned char busy_on_call_result[] = { 0x02 };
+	struct ofono_voicecall *vc = NULL;
+	struct ofono_atom *vc_atom;
+	int err;
+
+	if (qualifier > 5) {
+		rsp->result.type = STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD;
+		return TRUE;
+	}
+
+	/*
+	 * Passing called party subaddress and establishing non-speech
+	 * calls are not supported.
+	 */
+	if (sc->ccp.len || sc->subaddr.len) {
+		rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		return TRUE;
+	}
+
+	vc_atom = __ofono_modem_find_atom(__ofono_atom_get_modem(stk->atom),
+						OFONO_ATOM_TYPE_VOICECALL);
+	if (vc_atom)
+		vc = __ofono_atom_get_data(vc_atom);
+
+	if (!vc) {
+		rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		return TRUE;
+	}
+
+	if (__ofono_voicecall_busy(vc) && (qualifier == 0 || qualifier == 1)) {
+		rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+		rsp->result.additional_len = sizeof(busy_on_call_result);
+		rsp->result.additional = busy_on_call_result;
+		return TRUE;
+	}
+
+	stk->cancel_cmd = stk_request_cancel;
+
+	err = stk_agent_confirm_call(stk->current_agent, sc->alpha_id_usr_cfm,
+					0, confirm_call_cb, stk, NULL,
+					stk->timeout * 1000);
+
+	if (err < 0) {
+		/*
+		 * We most likely got an out of memory error, tell SIM
+		 * to retry
+		 */
+		rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
 static void stk_proactive_command_cancel(struct ofono_stk *stk)
 {
 	if (stk->immediate_response)
@@ -1482,6 +1674,7 @@ void ofono_stk_proactive_command_notify(struct ofono_stk *stk,
 		case STK_COMMAND_TYPE_GET_INKEY:
 		case STK_COMMAND_TYPE_GET_INPUT:
 		case STK_COMMAND_TYPE_PLAY_TONE:
+		case STK_COMMAND_TYPE_SETUP_CALL:
 			send_simple_response(stk, STK_RESULT_TYPE_NOT_CAPABLE);
 			return;
 
@@ -1543,6 +1736,11 @@ void ofono_stk_proactive_command_notify(struct ofono_stk *stk,
 							&rsp, stk);
 		break;
 
+	case STK_COMMAND_TYPE_SETUP_CALL:
+		respond = handle_command_set_up_call(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
 	default:
 		rsp.result.type = STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD;
 		break;
-- 
1.7.1.86.g0e460.dirty

Re: [PATCH 1/3] stkagent: Add ConfirmCallSetup request.

[Denis Kenzior]

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

Hi Andrew,

On 08/25/2010 10:49 AM, Andrzej Zaborowski wrote:
> ---
>  src/stkagent.c |   65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  src/stkagent.h |    5 ++++
>  2 files changed, 70 insertions(+), 0 deletions(-)

Patch has been applied, thanks.

Regards,
-Denis