Hi Mikel, On 10/12/2011 07:35 AM, Mikel Astiz wrote: Patch has been applied, however I amended it slightly due to a compiler error. I also moved this part to happen before registering in a later commit. 1 less signal emission to worry about ;) Regards, -Denis

Hi Mikel, On 10/12/2011 07:35 AM, Mikel Astiz wrote: Why exactly are you using parse_reg_unsolicited here? That one is meant to parse +CREG/+CGREG unsolicited responses, probably not the right thing for BSIR, just using g_at_result_iter_next_number would be enough here. If you don't use the at_util_parse_reg_unsolicited then you don't need the vendor information. Regards, -Denis

--- doc/handsfree-api.txt | 13 +++++++++++++ 1 files changed, 13 insertions(+), 0 deletions(-) diff --git a/doc/handsfree-api.txt b/doc/handsfree-api.txt index 4b2b156..023233c 100644 --- a/doc/handsfree-api.txt +++ b/doc/handsfree-api.txt @@ -20,6 +20,19 @@ Methods dict GetProperties() Possible Errors: [service].Error.InProgress [service].Error.InvalidArguments + string RequestPhoneNumber() + + Request a phone number from the AG, corresponding to the + last voice tag recorded in the HF. The AG may accept or + reject this request depending on its internal state. + + This functionality is generally implemented by using + the +BINP=1 AT command. + + Possible Errors: [service].Error.InProgress + [service].Error.InvalidArguments + [service].Error.Failed + Signals PropertyChanged(string property, variant value) Signal is emitted whenever a property has changed. -- 1.7.6.4

--- src/handsfree.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 49 insertions(+), 0 deletions(-) diff --git a/src/handsfree.c b/src/handsfree.c index ae5007e..42b71ea 100644 --- a/src/handsfree.c +++ b/src/handsfree.c @@ -48,6 +48,7 @@ struct ofono_handsfree { const struct ofono_handsfree_driver *driver; void *driver_data; struct ofono_atom *atom; + DBusMessage *pending; }; void ofono_handsfree_set_inband_ringing(struct ofono_handsfree *hf, @@ -119,11 +120,53 @@ static DBusMessage *handsfree_set_property(DBusConnection *conn, return __ofono_error_invalid_args(msg); } +static void request_phone_number_cb(const struct ofono_error *error, + const struct ofono_phone_number *number, + void *data) +{ + struct ofono_handsfree *hf = data; + DBusMessage *reply; + const char *phone_number; + + if (error->type != OFONO_ERROR_TYPE_NO_ERROR) { + DBG("Phone number request callback returned error: %s", + telephony_error_to_str(error)); + + reply = __ofono_error_failed(hf->pending); + __ofono_dbus_pending_reply(&hf->pending, reply); + return; + } + + phone_number = phone_number_to_string(number); + reply = dbus_message_new_method_return(hf->pending); + dbus_message_append_args(reply, DBUS_TYPE_STRING, &phone_number, + DBUS_TYPE_INVALID); + __ofono_dbus_pending_reply(&hf->pending, reply); +} + +static DBusMessage *handsfree_request_phone_number(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct ofono_handsfree *hf = data; + + if (hf->pending) + return __ofono_error_busy(msg); + + if (!hf->driver->request_phone_number) + return __ofono_error_not_supported(msg); + + hf->pending = dbus_message_ref(msg); + hf->driver->request_phone_number(hf, request_phone_number_cb, hf); + return NULL; +} + static GDBusMethodTable handsfree_methods[] = { { "GetProperties", "", "a{sv}", handsfree_get_properties, G_DBUS_METHOD_FLAG_ASYNC }, { "SetProperty", "sv", "", handsfree_set_property, G_DBUS_METHOD_FLAG_ASYNC }, + { "RequestPhoneNumber", "", "s", handsfree_request_phone_number, + G_DBUS_METHOD_FLAG_ASYNC }, { NULL, NULL, NULL, NULL } }; @@ -187,6 +230,12 @@ static void handsfree_unregister(struct ofono_atom *atom) DBusConnection *conn = ofono_dbus_get_connection(); struct ofono_modem *modem = __ofono_atom_get_modem(atom); const char *path = __ofono_atom_get_path(atom); + struct ofono_handsfree *hf = __ofono_atom_get_data(atom); + + if (hf->pending) { + DBusMessage *reply = __ofono_error_failed(hf->pending); + __ofono_dbus_pending_reply(&hf->pending, reply); + } ofono_modem_remove_interface(modem, OFONO_HANDSFREE_INTERFACE); g_dbus_unregister_interface(conn, path, -- 1.7.6.4

--- drivers/hfpmodem/handsfree.c | 59 ++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 59 insertions(+), 0 deletions(-) diff --git a/drivers/hfpmodem/handsfree.c b/drivers/hfpmodem/handsfree.c index be6b83c..392e5b7 100644 --- a/drivers/hfpmodem/handsfree.c +++ b/drivers/hfpmodem/handsfree.c @@ -42,6 +42,8 @@ #include "hfpmodem.h" #include "slc.h" +static const char *binp_prefix[] = { "+BINP:", NULL }; + struct hf_data { GAtChat *chat; unsigned int ag_features; @@ -105,10 +107,67 @@ static void hfp_handsfree_remove(struct ofono_handsfree *hf) g_free(hd); } +static void hfp_request_phone_number_cb(gboolean ok, GAtResult *result, + gpointer user_data) +{ + struct cb_data *cbd = user_data; + ofono_handsfree_phone_cb_t cb = cbd->cb; + void *data = cbd->data; + GAtResultIter iter; + const char *num; + int type; + struct ofono_phone_number phone_number; + + if (!ok) + goto fail; + + g_at_result_iter_init(&iter, result); + + if (!g_at_result_iter_next(&iter, "+BINP:")) + goto fail; + + if (!g_at_result_iter_next_string(&iter, &num)) + goto fail; + + if (!g_at_result_iter_next_number(&iter, &type)) + goto fail; + + DBG("AT+BINP=1 response: %s %d", num, type); + + strncpy(phone_number.number, num, + OFONO_MAX_PHONE_NUMBER_LENGTH); + phone_number.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0'; + phone_number.type = type; + + CALLBACK_WITH_SUCCESS(cb, &phone_number, data); + return; + +fail: + CALLBACK_WITH_FAILURE(cb, NULL, data); +} + +static void hfp_request_phone_number(struct ofono_handsfree *hf, + ofono_handsfree_phone_cb_t cb, + void *data) +{ + struct hf_data *hd = ofono_handsfree_get_data(hf); + struct cb_data *cbd = cb_data_new(cb, data); + + if (g_at_chat_send(hd->chat, "AT+BINP=1", binp_prefix, + hfp_request_phone_number_cb, + cbd, g_free) > 0) + return; + + g_free(cbd); + + CALLBACK_WITH_FAILURE(cb, NULL, data); +} + static struct ofono_handsfree_driver driver = { .name = "hfpmodem", .probe = hfp_handsfree_probe, .remove = hfp_handsfree_remove, + .request_phone_number = hfp_request_phone_number, }; void hfp_handsfree_init(void) -- 1.7.6.4

--- src/handsfree.c | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-) diff --git a/src/handsfree.c b/src/handsfree.c index 42b71ea..579434b 100644 --- a/src/handsfree.c +++ b/src/handsfree.c @@ -161,8 +161,7 @@ static DBusMessage *handsfree_request_phone_number(DBusConnection *conn, } static GDBusMethodTable handsfree_methods[] = { - { "GetProperties", "", "a{sv}", handsfree_get_properties, - G_DBUS_METHOD_FLAG_ASYNC }, + { "GetProperties", "", "a{sv}", handsfree_get_properties }, { "SetProperty", "sv", "", handsfree_set_property, G_DBUS_METHOD_FLAG_ASYNC }, { "RequestPhoneNumber", "", "s", handsfree_request_phone_number, -- 1.7.6.4

--- doc/handsfree-api.txt | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-) diff --git a/doc/handsfree-api.txt b/doc/handsfree-api.txt index 023233c..9355946 100644 --- a/doc/handsfree-api.txt +++ b/doc/handsfree-api.txt @@ -41,3 +41,10 @@ Signals PropertyChanged(string property, variant value) Properties boolean InbandRinging [readonly] Boolean representing whether inband ringing is enabled. + + boolean VoiceRecognition [readwrite] + + Boolean representing whether voice recognition is + currently active in the AG. This property may be written + to activate or deactivate the function from the HF, or + the AG could autonomously initiate it. -- 1.7.6.4

--- src/handsfree.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 72 insertions(+), 0 deletions(-) diff --git a/src/handsfree.c b/src/handsfree.c index 579434b..bf30b9c 100644 --- a/src/handsfree.c +++ b/src/handsfree.c @@ -45,6 +45,9 @@ static GSList *g_drivers = NULL; struct ofono_handsfree { ofono_bool_t inband_ringing; + ofono_bool_t voicerec_state; + ofono_bool_t pending_voicerec_state; + const struct ofono_handsfree_driver *driver; void *driver_data; struct ofono_atom *atom; @@ -69,6 +72,24 @@ void ofono_handsfree_set_inband_ringing(struct ofono_handsfree *hf, &dbus_enabled); } +void ofono_handsfree_set_voice_recognition(struct ofono_handsfree *hf, + ofono_bool_t enabled) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + const char *path = __ofono_atom_get_path(hf->atom); + dbus_bool_t dbus_enabled = enabled; + + if (hf->voicerec_state == enabled) + return; + + hf->voicerec_state = enabled; + + ofono_dbus_signal_property_changed(conn, path, + OFONO_HANDSFREE_INTERFACE, + "VoiceRecognition", DBUS_TYPE_BOOLEAN, + &dbus_enabled); +} + static DBusMessage *handsfree_get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -77,6 +98,7 @@ static DBusMessage *handsfree_get_properties(DBusConnection *conn, DBusMessageIter iter; DBusMessageIter dict; dbus_bool_t inband_ringing; + dbus_bool_t voicerec_state; reply = dbus_message_new_method_return(msg); if (reply == NULL) @@ -92,17 +114,49 @@ static DBusMessage *handsfree_get_properties(DBusConnection *conn, ofono_dbus_dict_append(&dict, "InbandRinging", DBUS_TYPE_BOOLEAN, &inband_ringing); + voicerec_state = hf->voicerec_state; + ofono_dbus_dict_append(&dict, "VoiceRecognition", DBUS_TYPE_BOOLEAN, + &voicerec_state); + dbus_message_iter_close_container(&iter, &dict); return reply; } +static void voicerec_set_cb(const struct ofono_error *error, void *data) +{ + struct ofono_handsfree *hf = data; + DBusConnection *conn = ofono_dbus_get_connection(); + const char *path = __ofono_atom_get_path(hf->atom); + + if (error->type != OFONO_ERROR_TYPE_NO_ERROR) { + __ofono_dbus_pending_reply(&hf->pending, + __ofono_error_failed(hf->pending)); + return; + } + + hf->voicerec_state = hf->pending_voicerec_state; + + __ofono_dbus_pending_reply(&hf->pending, + dbus_message_new_method_return(hf->pending)); + + ofono_dbus_signal_property_changed(conn, path, + OFONO_HANDSFREE_INTERFACE, + "VoiceRecognition", + DBUS_TYPE_BOOLEAN, + &hf->voicerec_state); +} + static DBusMessage *handsfree_set_property(DBusConnection *conn, DBusMessage *msg, void *data) { + struct ofono_handsfree *hf = data; DBusMessageIter iter, var; const char *name; + if (hf->pending) + return __ofono_error_busy(msg); + if (dbus_message_iter_init(msg, &iter) == FALSE) return __ofono_error_invalid_args(msg); @@ -117,6 +171,24 @@ static DBusMessage *handsfree_set_property(DBusConnection *conn, dbus_message_iter_recurse(&iter, &var); + if (g_str_equal(name, "VoiceRecognition") == TRUE) { + ofono_bool_t enabled; + + if (!hf->driver->voice_recognition) + return __ofono_error_not_implemented(msg); + + if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN) + return __ofono_error_invalid_args(msg); + + dbus_message_iter_get_basic(&var, &enabled); + + hf->pending_voicerec_state = enabled; + hf->pending = dbus_message_ref(msg); + hf->driver->voice_recognition(hf, enabled, voicerec_set_cb, hf); + + return NULL; + } + return __ofono_error_invalid_args(msg); } -- 1.7.6.4

--- doc/handsfree-api.txt | 17 ++++++++++++++++- 1 files changed, 16 insertions(+), 1 deletions(-) diff --git a/doc/handsfree-api.txt b/doc/handsfree-api.txt index 9355946..dafb0ed 100644 --- a/doc/handsfree-api.txt +++ b/doc/handsfree-api.txt @@ -38,7 +38,22 @@ Signals PropertyChanged(string property, variant value) Signal is emitted whenever a property has changed. The new value is passed as the signal argument. -Properties boolean InbandRinging [readonly] +Properties array{string} Features [readonly] + + List of features supported by the AG. The currently + supported values are: + "3WayCalling" + "ECNR" + "VoiceRecognition" + "InbandRinging" + "AttachVoiceTag" + "RejectCall" + "EnhancedCallStatus" + "EnhancedCallControl" + "ExtendedResultCodes" + "CodecNegotiation" + + boolean InbandRinging [readonly] Boolean representing whether inband ringing is enabled. -- 1.7.6.4

--- src/handsfree.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 80 insertions(+), 0 deletions(-) diff --git a/src/handsfree.c b/src/handsfree.c index bf30b9c..e19d9d3 100644 --- a/src/handsfree.c +++ b/src/handsfree.c @@ -41,9 +41,12 @@ #include "ofono.h" #include "common.h" +#define MAX_AG_FEATURE_COUNT 32 + static GSList *g_drivers = NULL; struct ofono_handsfree { + unsigned int ag_features; ofono_bool_t inband_ringing; ofono_bool_t voicerec_state; ofono_bool_t pending_voicerec_state; @@ -54,6 +57,76 @@ struct ofono_handsfree { DBusMessage *pending; }; +static void append_ag_features(struct ofono_handsfree *hf, char **features) +{ + unsigned int bit; + int feature_count = 0; + + for (bit = 1; bit != 0; bit <<= 1) { + if (hf->ag_features & bit) { + char *name = NULL; + + switch ((enum hfp_ag_feature) bit) { + case HFP_AG_FEATURE_3WAY: + name = "3WayCalling"; + break; + case HFP_AG_FEATURE_ECNR: + name = "ECNR"; + break; + case HFP_AG_FEATURE_VOICE_RECOG: + name = "VoiceRecognition"; + break; + case HFP_AG_FEATURE_IN_BAND_RING_TONE: + name = "InbandRinging"; + break; + case HFP_AG_FEATURE_ATTACH_VOICE_TAG: + name = "AttachVoiceTag"; + break; + case HFP_AG_FEATURE_REJECT_CALL: + name = "RejectCall"; + break; + case HFP_AG_FEATURE_ENHANCED_CALL_STATUS: + name = "EnhancedCallStatus"; + break; + case HFP_AG_FEATURE_ENHANCED_CALL_CONTROL: + name = "EnhancedCallControl"; + break; + case HFP_AG_FEATURE_EXTENDED_RES_CODE: + name = "ExtendedResultCodes"; + break; + case HFP_AG_FEATURE_CODEC_NEGOTIATION: + name = "CodecNegotiation"; + break; + } + + features[feature_count++] = name; + } + } + + features[feature_count] = NULL; +} + +void ofono_handsfree_set_ag_features(struct ofono_handsfree *hf, + unsigned int ag_features) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + const char *path = __ofono_atom_get_path(hf->atom); + char **features; + + if (hf->ag_features == ag_features) + return; + + hf->ag_features = ag_features; + + features = g_new0(char *, MAX_AG_FEATURE_COUNT + 1); + append_ag_features(hf, features); + ofono_dbus_signal_array_property_changed(conn, path, + OFONO_HANDSFREE_INTERFACE, + "Features", DBUS_TYPE_STRING, + &features); + g_free(features); +} + void ofono_handsfree_set_inband_ringing(struct ofono_handsfree *hf, ofono_bool_t enabled) { @@ -99,6 +172,7 @@ static DBusMessage *handsfree_get_properties(DBusConnection *conn, DBusMessageIter dict; dbus_bool_t inband_ringing; dbus_bool_t voicerec_state; + char **features; reply = dbus_message_new_method_return(msg); if (reply == NULL) @@ -118,6 +192,12 @@ static DBusMessage *handsfree_get_properties(DBusConnection *conn, ofono_dbus_dict_append(&dict, "VoiceRecognition", DBUS_TYPE_BOOLEAN, &voicerec_state); + features = g_new0(char *, MAX_AG_FEATURE_COUNT + 1); + append_ag_features(hf, features); + ofono_dbus_dict_append_array(&dict, "Features", DBUS_TYPE_STRING, + &features); + g_free(features); + dbus_message_iter_close_container(&iter, &dict); return reply; -- 1.7.6.4

Some phones can have trouble when using the strict AT syntax parser for HFP. So far, this has only been evidenced with the Samsung Wave, which works fine with the permissive syntax parser. Several other phones have been tested with the permissive parser and seem to work OK. --- plugins/hfp_hf.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/plugins/hfp_hf.c b/plugins/hfp_hf.c index 1008696..58ebc64 100644 --- a/plugins/hfp_hf.c +++ b/plugins/hfp_hf.c @@ -135,7 +135,7 @@ static int service_level_connection(struct ofono_modem *modem, int fd) return -EIO; } - syntax = g_at_syntax_new_gsmv1(); + syntax = g_at_syntax_new_gsm_permissive(); chat = g_at_chat_new(io, syntax); g_at_syntax_unref(syntax); g_io_channel_unref(io); -- 1.7.6.4