| /* |
| * |
| * oFono - Open Source Telephony |
| * |
| * Copyright (C) 2008-2011 Intel Corporation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <stdbool.h> |
| #include <errno.h> |
| |
| #include <glib.h> |
| |
| #include <ofono/handsfree-audio.h> |
| |
| #include "ofono.h" |
| #include "common.h" |
| #include "hfp.h" |
| #include "gatserver.h" |
| #include "gatppp.h" |
| |
| #define RING_TIMEOUT 3 |
| |
| #define CVSD_OFFSET 0 |
| #define MSBC_OFFSET 1 |
| #define CODECS_COUNT (MSBC_OFFSET + 1) |
| |
| struct hfp_codec_info { |
| unsigned char type; |
| ofono_bool_t supported; |
| }; |
| |
| struct ofono_emulator { |
| struct ofono_atom *atom; |
| enum ofono_emulator_type type; |
| GAtServer *server; |
| GAtPPP *ppp; |
| int l_features; |
| int r_features; |
| GSList *indicators; |
| guint callsetup_source; |
| int pns_id; |
| struct ofono_handsfree_card *card; |
| struct hfp_codec_info r_codecs[CODECS_COUNT]; |
| unsigned char selected_codec; |
| unsigned char negotiated_codec; |
| unsigned char proposed_codec; |
| ofono_emulator_codec_negotiation_cb codec_negotiation_cb; |
| void *codec_negotiation_data; |
| ofono_bool_t bac_received; |
| bool slc : 1; |
| unsigned int events_mode : 2; |
| bool events_ind : 1; |
| unsigned int cmee_mode : 2; |
| bool clip : 1; |
| bool ccwa : 1; |
| bool ddr_active : 1; |
| }; |
| |
| struct indicator { |
| char *name; |
| int value; |
| int min; |
| int max; |
| gboolean deferred; |
| gboolean active; |
| gboolean mandatory; |
| }; |
| |
| static void emulator_debug(const char *str, void *data) |
| { |
| ofono_info("%s: %s\n", (char *)data, str); |
| } |
| |
| static void emulator_disconnect(gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| DBG("%p", em); |
| |
| ofono_emulator_remove(em); |
| } |
| |
| static void ppp_connect(const char *iface, const char *local, |
| const char *remote, |
| const char *dns1, const char *dns2, |
| gpointer user_data) |
| { |
| DBG("Network Device: %s\n", iface); |
| DBG("IP Address: %s\n", local); |
| DBG("Remote IP Address: %s\n", remote); |
| DBG("Primary DNS Server: %s\n", dns1); |
| DBG("Secondary DNS Server: %s\n", dns2); |
| } |
| |
| static void cleanup_ppp(struct ofono_emulator *em) |
| { |
| DBG(""); |
| |
| g_at_ppp_unref(em->ppp); |
| em->ppp = NULL; |
| |
| __ofono_private_network_release(em->pns_id); |
| em->pns_id = 0; |
| |
| g_at_server_resume(em->server); |
| g_at_server_send_final(em->server, G_AT_SERVER_RESULT_NO_CARRIER); |
| } |
| |
| static void ppp_disconnect(GAtPPPDisconnectReason reason, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| cleanup_ppp(em); |
| } |
| |
| static void ppp_suspend(gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| DBG(""); |
| |
| g_at_server_resume(em->server); |
| } |
| |
| static void suspend_server(gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtIO *io = g_at_server_get_io(em->server); |
| |
| g_at_server_suspend(em->server); |
| |
| if (g_at_ppp_listen(em->ppp, io) == FALSE) |
| cleanup_ppp(em); |
| } |
| |
| static void request_private_network_cb( |
| const struct ofono_private_network_settings *pns, |
| void *data) |
| { |
| struct ofono_emulator *em = data; |
| GAtIO *io = g_at_server_get_io(em->server); |
| |
| if (pns == NULL) |
| goto error; |
| |
| em->ppp = g_at_ppp_server_new_full(pns->server_ip, pns->fd); |
| if (em->ppp == NULL) { |
| close(pns->fd); |
| goto badalloc; |
| } |
| |
| g_at_ppp_set_server_info(em->ppp, pns->peer_ip, |
| pns->primary_dns, pns->secondary_dns); |
| |
| g_at_ppp_set_acfc_enabled(em->ppp, TRUE); |
| g_at_ppp_set_pfc_enabled(em->ppp, TRUE); |
| |
| g_at_ppp_set_credentials(em->ppp, "", ""); |
| g_at_ppp_set_debug(em->ppp, emulator_debug, "PPP"); |
| |
| g_at_ppp_set_connect_function(em->ppp, ppp_connect, em); |
| g_at_ppp_set_disconnect_function(em->ppp, ppp_disconnect, em); |
| g_at_ppp_set_suspend_function(em->ppp, ppp_suspend, em); |
| |
| g_at_server_send_intermediate(em->server, "CONNECT"); |
| g_at_io_set_write_done(io, suspend_server, em); |
| |
| return; |
| |
| badalloc: |
| __ofono_private_network_release(em->pns_id); |
| |
| error: |
| em->pns_id = 0; |
| g_at_server_send_final(em->server, G_AT_SERVER_RESULT_ERROR); |
| } |
| |
| static gboolean dial_call(struct ofono_emulator *em, const char *dial_str) |
| { |
| char c = *dial_str; |
| |
| DBG("dial call %s", dial_str); |
| |
| if (c == '*' || c == '#' || c == 'T' || c == 't') { |
| if (__ofono_private_network_request(request_private_network_cb, |
| &em->pns_id, em) == FALSE) |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static void dial_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| const char *dial_str; |
| |
| DBG(""); |
| |
| if (type != G_AT_SERVER_REQUEST_TYPE_SET) |
| goto error; |
| |
| g_at_result_iter_init(&iter, result); |
| |
| if (!g_at_result_iter_next(&iter, "")) |
| goto error; |
| |
| dial_str = g_at_result_iter_raw_line(&iter); |
| if (!dial_str) |
| goto error; |
| |
| if (em->ppp) |
| goto error; |
| |
| if (!dial_call(em, dial_str)) |
| goto error; |
| |
| return; |
| |
| error: |
| g_at_server_send_final(em->server, G_AT_SERVER_RESULT_ERROR); |
| } |
| |
| static void dun_ath_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| |
| DBG(""); |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE) |
| goto error; |
| |
| if (val != 0) |
| goto error; |
| |
| /* Fall through */ |
| |
| case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY: |
| if (em->ppp == NULL) |
| goto error; |
| |
| g_at_ppp_unref(em->ppp); |
| em->ppp = NULL; |
| |
| __ofono_private_network_release(em->pns_id); |
| em->pns_id = 0; |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| error: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void resume_ppp(gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| g_at_server_suspend(em->server); |
| g_at_ppp_resume(em->ppp); |
| } |
| |
| static void dun_ato_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtIO *io = g_at_server_get_io(em->server); |
| GAtResultIter iter; |
| int val; |
| |
| DBG(""); |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE) |
| goto error; |
| |
| if (val != 0) |
| goto error; |
| |
| /* Fall through */ |
| case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY: |
| if (em->ppp == NULL) |
| goto error; |
| |
| g_at_server_send_intermediate(em->server, "CONNECT"); |
| g_at_io_set_write_done(io, resume_ppp, em); |
| break; |
| |
| default: |
| error: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static struct indicator *find_indicator(struct ofono_emulator *em, |
| const char *name, int *index) |
| { |
| GSList *l; |
| int i; |
| |
| for (i = 1, l = em->indicators; l; l = l->next, i++) { |
| struct indicator *ind = l->data; |
| |
| if (g_str_equal(ind->name, name) == FALSE) |
| continue; |
| |
| if (index) |
| *index = i; |
| |
| return ind; |
| } |
| |
| return NULL; |
| } |
| |
| static struct ofono_call *find_call_with_status(struct ofono_emulator *em, |
| int status) |
| { |
| struct ofono_modem *modem = __ofono_atom_get_modem(em->atom); |
| struct ofono_voicecall *vc; |
| |
| vc = __ofono_atom_find(OFONO_ATOM_TYPE_VOICECALL, modem); |
| if (vc == NULL) |
| return NULL; |
| |
| return __ofono_voicecall_find_call_with_status(vc, status); |
| } |
| |
| static void notify_deferred_indicators(GAtServer *server, void *user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| int i; |
| char buf[20]; |
| GSList *l; |
| struct indicator *ind; |
| |
| for (i = 1, l = em->indicators; l; l = l->next, i++) { |
| ind = l->data; |
| |
| if (!ind->deferred) |
| continue; |
| |
| if (em->events_mode == 3 && em->events_ind && em->slc && |
| ind->active) { |
| sprintf(buf, "+CIEV: %d,%d", i, ind->value); |
| g_at_server_send_unsolicited(em->server, buf); |
| } |
| |
| ind->deferred = FALSE; |
| } |
| } |
| |
| static gboolean notify_ccwa(void *user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| struct ofono_call *c; |
| const char *phone; |
| /* |
| * '+CCWA: "+",' + phone number + phone type on 3 digits max |
| * + terminating null |
| */ |
| char str[OFONO_MAX_PHONE_NUMBER_LENGTH + 14 + 1]; |
| |
| if ((em->type == OFONO_EMULATOR_TYPE_HFP && em->slc == FALSE) || |
| !em->ccwa) |
| goto end; |
| |
| c = find_call_with_status(em, CALL_STATUS_WAITING); |
| |
| if (c && c->clip_validity == CLIP_VALIDITY_VALID) { |
| phone = phone_number_to_string(&c->phone_number); |
| sprintf(str, "+CCWA: \"%s\",%d", phone, c->phone_number.type); |
| |
| g_at_server_send_unsolicited(em->server, str); |
| } else |
| g_at_server_send_unsolicited(em->server, "+CCWA: \"\",128"); |
| |
| end: |
| em->callsetup_source = 0; |
| |
| return FALSE; |
| } |
| |
| static gboolean notify_ring(void *user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| struct ofono_call *c; |
| const char *phone; |
| /* |
| * '+CLIP: "+",' + phone number + phone type on 3 digits max |
| * + terminating null |
| */ |
| char str[OFONO_MAX_PHONE_NUMBER_LENGTH + 14 + 1]; |
| |
| if (em->type == OFONO_EMULATOR_TYPE_HFP && em->slc == FALSE) |
| return TRUE; |
| |
| g_at_server_send_unsolicited(em->server, "RING"); |
| |
| if (!em->clip) |
| return TRUE; |
| |
| c = find_call_with_status(em, CALL_STATUS_INCOMING); |
| |
| if (c == NULL) |
| return TRUE; |
| |
| switch (c->clip_validity) { |
| case CLIP_VALIDITY_VALID: |
| phone = phone_number_to_string(&c->phone_number); |
| sprintf(str, "+CLIP: \"%s\",%d", phone, c->phone_number.type); |
| g_at_server_send_unsolicited(em->server, str); |
| break; |
| |
| case CLIP_VALIDITY_WITHHELD: |
| g_at_server_send_unsolicited(em->server, "+CLIP: \"\",128"); |
| break; |
| } |
| |
| return TRUE; |
| } |
| |
| static void brsf_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| char buf[16]; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE) |
| goto fail; |
| |
| if (val < 0 || val > 0xffff) |
| goto fail; |
| |
| em->r_features = val; |
| |
| sprintf(buf, "+BRSF: %d", em->l_features); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void cind_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GSList *l; |
| struct indicator *ind; |
| gsize size; |
| int len; |
| char *buf; |
| char *tmp; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_QUERY: |
| /* |
| * "+CIND: " + terminating null + number of indicators * |
| * (max of 3 digits in the value + separator) |
| */ |
| size = 7 + 1 + (g_slist_length(em->indicators) * 4); |
| buf = g_try_malloc0(size); |
| if (buf == NULL) |
| goto fail; |
| |
| len = sprintf(buf, "+CIND: "); |
| tmp = buf + len; |
| |
| for (l = em->indicators; l; l = l->next) { |
| ind = l->data; |
| len = sprintf(tmp, "%s%d", |
| l == em->indicators ? "" : ",", |
| ind->value); |
| tmp = tmp + len; |
| } |
| |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_free(buf); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SUPPORT: |
| /* |
| * '+CIND: ' + terminating null + number of indicators * |
| * ( indicator name + '("",(000,000))' + separator) |
| */ |
| size = 8; |
| |
| for (l = em->indicators; l; l = l->next) { |
| ind = l->data; |
| size += strlen(ind->name) + 15; |
| } |
| |
| buf = g_try_malloc0(size); |
| if (buf == NULL) |
| goto fail; |
| |
| len = sprintf(buf, "+CIND: "); |
| tmp = buf + len; |
| |
| for (l = em->indicators; l; l = l->next) { |
| ind = l->data; |
| len = sprintf(tmp, "%s(\"%s\",(%d%c%d))", |
| l == em->indicators ? "" : ",", |
| ind->name, ind->min, |
| (ind->max - ind->min) == 1 ? ',' : '-', |
| ind->max); |
| tmp = tmp + len; |
| } |
| |
| g_at_server_send_info(server, buf, TRUE); |
| g_free(buf); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void cmer_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| char buf[32]; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_QUERY: |
| sprintf(buf, "+CMER: %d,0,0,%d,0", em->events_mode, |
| em->events_ind); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SUPPORT: |
| sprintf(buf, "+CMER: (0,3),(0),(0),(0,1),(0)"); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| { |
| GAtResultIter iter; |
| int mode = em->events_mode; |
| int ind = em->events_ind; |
| int val; |
| |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| /* mode */ |
| if (!g_at_result_iter_next_number_default(&iter, mode, &mode)) |
| goto fail; |
| |
| if (mode != 0 && mode != 3) |
| goto fail; |
| |
| /* keyp */ |
| if (!g_at_result_iter_next_number_default(&iter, 0, &val)) { |
| if (!g_at_result_iter_skip_next(&iter)) |
| goto done; |
| goto fail; |
| } |
| |
| if (val != 0) |
| goto fail; |
| |
| /* disp */ |
| if (!g_at_result_iter_next_number_default(&iter, 0, &val)) { |
| if (!g_at_result_iter_skip_next(&iter)) |
| goto done; |
| goto fail; |
| } |
| |
| if (val != 0) |
| goto fail; |
| |
| /* ind */ |
| if (!g_at_result_iter_next_number_default(&iter, ind, &ind)) { |
| if (!g_at_result_iter_skip_next(&iter)) |
| goto done; |
| goto fail; |
| } |
| |
| if (ind != 0 && ind != 1) |
| goto fail; |
| |
| /* bfr */ |
| if (!g_at_result_iter_next_number_default(&iter, 0, &val)) { |
| if (!g_at_result_iter_skip_next(&iter)) |
| goto done; |
| goto fail; |
| } |
| |
| if (val != 0) |
| goto fail; |
| |
| /* check that bfr is last parameter */ |
| if (g_at_result_iter_skip_next(&iter)) |
| goto fail; |
| |
| done: |
| em->events_mode = mode; |
| em->events_ind = ind; |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| __ofono_emulator_slc_condition(em, |
| OFONO_EMULATOR_SLC_CONDITION_CMER); |
| break; |
| } |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void clip_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| |
| if (em->slc == FALSE) |
| goto fail; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (!g_at_result_iter_next_number(&iter, &val)) |
| goto fail; |
| |
| if (val != 0 && val != 1) |
| goto fail; |
| |
| /* check this is last parameter */ |
| if (g_at_result_iter_skip_next(&iter)) |
| goto fail; |
| |
| em->clip = val; |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| }; |
| } |
| |
| static void ccwa_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| struct indicator *call_ind; |
| struct indicator *cs_ind; |
| |
| if (em->slc == FALSE) |
| goto fail; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (!g_at_result_iter_next_number(&iter, &val)) |
| goto fail; |
| |
| if (val != 0 && val != 1) |
| goto fail; |
| |
| /* check this is last parameter */ |
| if (g_at_result_iter_skip_next(&iter)) |
| goto fail; |
| |
| call_ind = find_indicator(em, OFONO_EMULATOR_IND_CALL, NULL); |
| cs_ind = find_indicator(em, OFONO_EMULATOR_IND_CALLSETUP, NULL); |
| |
| if (cs_ind->value == OFONO_EMULATOR_CALLSETUP_INCOMING && |
| call_ind->value == OFONO_EMULATOR_CALL_ACTIVE && |
| em->ccwa == FALSE && val == 1) |
| em->callsetup_source = g_timeout_add_seconds(0, |
| notify_ccwa, em); |
| |
| em->ccwa = val; |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| }; |
| } |
| |
| static void cmee_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| char buf[16]; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE) |
| goto fail; |
| |
| if (val != 0 && val != 1) |
| goto fail; |
| |
| em->cmee_mode = val; |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_QUERY: |
| sprintf(buf, "+CMEE: %d", em->cmee_mode); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SUPPORT: |
| /* HFP only support 0 and 1 */ |
| sprintf(buf, "+CMEE: (0,1)"); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void bia_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| { |
| GAtResultIter iter; |
| GSList *l; |
| int val; |
| |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| /* check validity of the request */ |
| while (g_at_result_iter_next_number_default(&iter, 0, &val)) |
| if (val != 0 && val != 1) |
| goto fail; |
| |
| /* Check that we have no non-numbers in the stream */ |
| if (g_at_result_iter_skip_next(&iter) == TRUE) |
| goto fail; |
| |
| /* request is valid, update the indicator activation status */ |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| for (l = em->indicators; l; l = l->next) { |
| struct indicator *ind = l->data; |
| |
| if (g_at_result_iter_next_number_default(&iter, |
| ind->active, &val) == FALSE) |
| break; |
| |
| if (ind->mandatory == TRUE) |
| continue; |
| |
| ind->active = val; |
| } |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| } |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void bind_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| char buf[128]; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_QUERY: |
| g_at_server_send_info(em->server, "+BIND: 1,1", TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| __ofono_emulator_slc_condition(em, |
| OFONO_EMULATOR_SLC_CONDITION_BIND); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SUPPORT: |
| sprintf(buf, "+BIND: (1)"); |
| g_at_server_send_info(em->server, buf, TRUE); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| { |
| GAtResultIter iter; |
| int hf_indicator; |
| int num_hf_indicators = 0; |
| |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| /* check validity of the request */ |
| while (num_hf_indicators < 20 && |
| g_at_result_iter_next_number(&iter, |
| &hf_indicator)) { |
| if (hf_indicator > 0xffff) |
| goto fail; |
| |
| num_hf_indicators += 1; |
| } |
| |
| /* Check that we have nothing extra in the stream */ |
| if (g_at_result_iter_skip_next(&iter) == TRUE) |
| goto fail; |
| |
| /* request is valid, update the indicator activation status */ |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| while (g_at_result_iter_next_number(&iter, &hf_indicator)) |
| ofono_info("HF supports indicator: 0x%04x", |
| hf_indicator); |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| break; |
| } |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void biev_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| { |
| GAtResultIter iter; |
| int hf_indicator; |
| int val; |
| |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (g_at_result_iter_next_number(&iter, &hf_indicator) == FALSE) |
| goto fail; |
| |
| if (hf_indicator != HFP_HF_INDICATOR_ENHANCED_SAFETY) |
| goto fail; |
| |
| if (em->ddr_active == FALSE) |
| goto fail; |
| |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE) |
| goto fail; |
| |
| if (val < 0 || val > 1) |
| goto fail; |
| |
| ofono_info("Enhanced Safety indicator: %d", val); |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| break; |
| } |
| |
| default: |
| fail: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| } |
| } |
| |
| static void finish_codec_negotiation(struct ofono_emulator *em, |
| int err) |
| { |
| if (em->codec_negotiation_cb == NULL) |
| return; |
| |
| em->codec_negotiation_cb(err, em->codec_negotiation_data); |
| |
| em->codec_negotiation_cb = NULL; |
| em->codec_negotiation_data = NULL; |
| } |
| |
| static void bac_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| |
| DBG(""); |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| /* |
| * CVSD codec is mandatory and must come first. |
| * See HFP v1.6 4.34.1 |
| */ |
| if (g_at_result_iter_next_number(&iter, &val) == FALSE || |
| val != HFP_CODEC_CVSD) |
| goto fail; |
| |
| em->bac_received = TRUE; |
| |
| em->negotiated_codec = 0; |
| em->r_codecs[CVSD_OFFSET].supported = TRUE; |
| |
| while (g_at_result_iter_next_number(&iter, &val)) { |
| switch (val) { |
| case HFP_CODEC_MSBC: |
| em->r_codecs[MSBC_OFFSET].supported = TRUE; |
| break; |
| default: |
| DBG("Unsupported HFP codec %d", val); |
| break; |
| } |
| } |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| /* |
| * If we're currently in the process of selecting a codec |
| * we have to restart that now |
| */ |
| if (em->proposed_codec) { |
| em->proposed_codec = 0; |
| ofono_emulator_start_codec_negotiation(em, NULL, NULL); |
| } |
| |
| break; |
| |
| default: |
| fail: |
| DBG("Process AT+BAC failed"); |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| |
| finish_codec_negotiation(em, -EIO); |
| |
| break; |
| } |
| } |
| |
| static void connect_sco(struct ofono_emulator *em) |
| { |
| int err; |
| |
| DBG(""); |
| |
| if (em->card == NULL) { |
| finish_codec_negotiation(em, -EINVAL); |
| return; |
| } |
| |
| err = ofono_handsfree_card_connect_sco(em->card); |
| if (err == 0) { |
| finish_codec_negotiation(em, 0); |
| return; |
| } |
| |
| /* If we have another codec we can try then lets do that */ |
| if (em->negotiated_codec != HFP_CODEC_CVSD) { |
| em->selected_codec = HFP_CODEC_CVSD; |
| ofono_emulator_start_codec_negotiation(em, |
| em->codec_negotiation_cb, |
| em->codec_negotiation_data); |
| return; |
| } |
| |
| finish_codec_negotiation(em, -EIO); |
| } |
| |
| static void bcs_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| GAtResultIter iter; |
| int val; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| g_at_result_iter_init(&iter, result); |
| g_at_result_iter_next(&iter, ""); |
| |
| if (!g_at_result_iter_next_number(&iter, &val)) |
| break; |
| |
| if (em->proposed_codec != val) { |
| em->proposed_codec = 0; |
| break; |
| } |
| |
| em->proposed_codec = 0; |
| em->negotiated_codec = val; |
| |
| DBG("negotiated codec %d", val); |
| |
| if (em->card != NULL) |
| ofono_handsfree_card_set_codec(em->card, |
| em->negotiated_codec); |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| connect_sco(em); |
| |
| return; |
| default: |
| break; |
| } |
| |
| finish_codec_negotiation(em, -EIO); |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| } |
| |
| static void bcc_cb(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer user_data) |
| { |
| struct ofono_emulator *em = user_data; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY: |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_OK); |
| |
| if (!em->negotiated_codec) { |
| ofono_emulator_start_codec_negotiation(em, NULL, NULL); |
| return; |
| } |
| |
| connect_sco(em); |
| |
| return; |
| default: |
| break; |
| } |
| |
| g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR); |
| } |
| |
| static void emulator_add_indicator(struct ofono_emulator *em, const char* name, |
| int min, int max, int dflt, |
| gboolean mandatory) |
| { |
| struct indicator *ind; |
| |
| ind = g_try_new0(struct indicator, 1); |
| if (ind == NULL) { |
| ofono_error("Unable to allocate indicator structure"); |
| return; |
| } |
| |
| ind->name = g_strdup(name); |
| ind->min = min; |
| ind->max = max; |
| ind->value = dflt; |
| ind->active = TRUE; |
| ind->mandatory = mandatory; |
| |
| em->indicators = g_slist_append(em->indicators, ind); |
| } |
| |
| static void emulator_unregister(struct ofono_atom *atom) |
| { |
| struct ofono_emulator *em = __ofono_atom_get_data(atom); |
| GSList *l; |
| |
| DBG("%p", em); |
| |
| if (em->callsetup_source) { |
| g_source_remove(em->callsetup_source); |
| em->callsetup_source = 0; |
| } |
| |
| for (l = em->indicators; l; l = l->next) { |
| struct indicator *ind = l->data; |
| |
| g_free(ind->name); |
| g_free(ind); |
| } |
| |
| g_slist_free(em->indicators); |
| em->indicators = NULL; |
| |
| g_at_ppp_unref(em->ppp); |
| em->ppp = NULL; |
| |
| if (em->pns_id > 0) { |
| __ofono_private_network_release(em->pns_id); |
| em->pns_id = 0; |
| } |
| |
| g_at_server_unref(em->server); |
| em->server = NULL; |
| |
| ofono_handsfree_card_remove(em->card); |
| em->card = NULL; |
| } |
| |
| void ofono_emulator_register(struct ofono_emulator *em, int fd) |
| { |
| GIOChannel *io; |
| |
| DBG("%p, %d", em, fd); |
| |
| if (fd < 0) |
| return; |
| |
| io = g_io_channel_unix_new(fd); |
| |
| em->server = g_at_server_new(io); |
| if (em->server == NULL) |
| return; |
| |
| g_io_channel_unref(io); |
| |
| g_at_server_set_debug(em->server, emulator_debug, "Server"); |
| g_at_server_set_disconnect_function(em->server, |
| emulator_disconnect, em); |
| g_at_server_set_finish_callback(em->server, notify_deferred_indicators, |
| em); |
| |
| if (em->type == OFONO_EMULATOR_TYPE_HFP) { |
| em->ddr_active = true; |
| |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_SERVICE, 0, 1, 0, |
| FALSE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_CALL, 0, 1, 0, |
| TRUE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_CALLSETUP, 0, 3, |
| 0, TRUE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_CALLHELD, 0, 2, |
| 0, TRUE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_SIGNAL, 0, 5, 0, |
| FALSE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_ROAMING, 0, 1, 0, |
| FALSE); |
| emulator_add_indicator(em, OFONO_EMULATOR_IND_BATTERY, 0, 5, 5, |
| FALSE); |
| |
| g_at_server_register(em->server, "+BRSF", brsf_cb, em, NULL); |
| g_at_server_register(em->server, "+CIND", cind_cb, em, NULL); |
| g_at_server_register(em->server, "+CMER", cmer_cb, em, NULL); |
| g_at_server_register(em->server, "+CLIP", clip_cb, em, NULL); |
| g_at_server_register(em->server, "+CCWA", ccwa_cb, em, NULL); |
| g_at_server_register(em->server, "+CMEE", cmee_cb, em, NULL); |
| g_at_server_register(em->server, "+BIA", bia_cb, em, NULL); |
| g_at_server_register(em->server, "+BIND", bind_cb, em, NULL); |
| g_at_server_register(em->server, "+BIEV", biev_cb, em, NULL); |
| g_at_server_register(em->server, "+BAC", bac_cb, em, NULL); |
| g_at_server_register(em->server, "+BCC", bcc_cb, em, NULL); |
| g_at_server_register(em->server, "+BCS", bcs_cb, em, NULL); |
| } |
| |
| __ofono_atom_register(em->atom, emulator_unregister); |
| |
| switch (em->type) { |
| case OFONO_EMULATOR_TYPE_DUN: |
| g_at_server_register(em->server, "D", dial_cb, em, NULL); |
| g_at_server_register(em->server, "H", dun_ath_cb, em, NULL); |
| g_at_server_register(em->server, "O", dun_ato_cb, em, NULL); |
| break; |
| case OFONO_EMULATOR_TYPE_HFP: |
| g_at_server_set_echo(em->server, FALSE); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void emulator_remove(struct ofono_atom *atom) |
| { |
| struct ofono_emulator *em = __ofono_atom_get_data(atom); |
| |
| DBG("atom: %p", atom); |
| |
| g_free(em); |
| } |
| |
| struct ofono_emulator *ofono_emulator_create(struct ofono_modem *modem, |
| enum ofono_emulator_type type) |
| { |
| struct ofono_emulator *em; |
| enum ofono_atom_type atom_t; |
| |
| DBG("modem: %p, type: %d", modem, type); |
| |
| if (type == OFONO_EMULATOR_TYPE_DUN) |
| atom_t = OFONO_ATOM_TYPE_EMULATOR_DUN; |
| else if (type == OFONO_EMULATOR_TYPE_HFP) |
| atom_t = OFONO_ATOM_TYPE_EMULATOR_HFP; |
| else |
| return NULL; |
| |
| em = g_try_new0(struct ofono_emulator, 1); |
| |
| if (em == NULL) |
| return NULL; |
| |
| em->type = type; |
| em->l_features |= HFP_AG_FEATURE_3WAY; |
| em->l_features |= HFP_AG_FEATURE_REJECT_CALL; |
| em->l_features |= HFP_AG_FEATURE_ENHANCED_CALL_STATUS; |
| em->l_features |= HFP_AG_FEATURE_ENHANCED_CALL_CONTROL; |
| em->l_features |= HFP_AG_FEATURE_EXTENDED_RES_CODE; |
| em->l_features |= HFP_AG_FEATURE_HF_INDICATORS; |
| em->l_features |= HFP_AG_FEATURE_CODEC_NEGOTIATION; |
| em->events_mode = 3; /* default mode is forwarding events */ |
| em->cmee_mode = 0; /* CME ERROR disabled by default */ |
| |
| em->atom = __ofono_modem_add_atom_offline(modem, atom_t, |
| emulator_remove, em); |
| |
| return em; |
| } |
| |
| void ofono_emulator_remove(struct ofono_emulator *em) |
| { |
| __ofono_atom_free(em->atom); |
| } |
| |
| void ofono_emulator_send_final(struct ofono_emulator *em, |
| const struct ofono_error *final) |
| { |
| char buf[256]; |
| |
| /* |
| * TODO: Handle various CMEE modes and report error strings from |
| * common.c |
| */ |
| switch (final->type) { |
| case OFONO_ERROR_TYPE_CMS: |
| sprintf(buf, "+CMS ERROR: %d", final->error); |
| g_at_server_send_ext_final(em->server, buf); |
| break; |
| |
| case OFONO_ERROR_TYPE_CME: |
| switch (em->cmee_mode) { |
| case 1: |
| sprintf(buf, "+CME ERROR: %d", final->error); |
| break; |
| |
| case 2: |
| sprintf(buf, "+CME ERROR: %s", |
| telephony_error_to_str(final)); |
| break; |
| |
| default: |
| goto failure; |
| } |
| |
| g_at_server_send_ext_final(em->server, buf); |
| break; |
| |
| case OFONO_ERROR_TYPE_NO_ERROR: |
| g_at_server_send_final(em->server, G_AT_SERVER_RESULT_OK); |
| break; |
| |
| case OFONO_ERROR_TYPE_CEER: |
| case OFONO_ERROR_TYPE_SIM: |
| case OFONO_ERROR_TYPE_FAILURE: |
| case OFONO_ERROR_TYPE_ERRNO: |
| failure: |
| g_at_server_send_final(em->server, G_AT_SERVER_RESULT_ERROR); |
| break; |
| }; |
| } |
| |
| void ofono_emulator_send_unsolicited(struct ofono_emulator *em, |
| const char *result) |
| { |
| g_at_server_send_unsolicited(em->server, result); |
| } |
| |
| void ofono_emulator_send_intermediate(struct ofono_emulator *em, |
| const char *result) |
| { |
| g_at_server_send_intermediate(em->server, result); |
| } |
| |
| void ofono_emulator_send_info(struct ofono_emulator *em, const char *line, |
| ofono_bool_t last) |
| { |
| g_at_server_send_info(em->server, line, last); |
| } |
| |
| struct handler { |
| ofono_emulator_request_cb_t cb; |
| void *data; |
| ofono_destroy_func destroy; |
| struct ofono_emulator *em; |
| }; |
| |
| struct ofono_emulator_request { |
| GAtResultIter iter; |
| enum ofono_emulator_request_type type; |
| }; |
| |
| static void handler_proxy(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer userdata) |
| { |
| struct handler *h = userdata; |
| struct ofono_emulator_request req; |
| |
| switch (type) { |
| case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY: |
| req.type = OFONO_EMULATOR_REQUEST_TYPE_COMMAND_ONLY; |
| break; |
| case G_AT_SERVER_REQUEST_TYPE_SET: |
| req.type = OFONO_EMULATOR_REQUEST_TYPE_SET; |
| break; |
| case G_AT_SERVER_REQUEST_TYPE_QUERY: |
| req.type = OFONO_EMULATOR_REQUEST_TYPE_QUERY; |
| break; |
| case G_AT_SERVER_REQUEST_TYPE_SUPPORT: |
| req.type = OFONO_EMULATOR_REQUEST_TYPE_SUPPORT; |
| } |
| |
| g_at_result_iter_init(&req.iter, result); |
| g_at_result_iter_next(&req.iter, ""); |
| |
| h->cb(h->em, &req, h->data); |
| } |
| |
| static void handler_proxy_need_slc(GAtServer *server, |
| GAtServerRequestType type, |
| GAtResult *result, gpointer userdata) |
| { |
| struct handler *h = userdata; |
| |
| if (h->em->slc == FALSE) { |
| g_at_server_send_final(h->em->server, G_AT_SERVER_RESULT_ERROR); |
| return; |
| } |
| |
| handler_proxy(server, type, result, userdata); |
| } |
| |
| static void handler_proxy_chld(GAtServer *server, GAtServerRequestType type, |
| GAtResult *result, gpointer userdata) |
| { |
| struct handler *h = userdata; |
| |
| if (h->em->slc == FALSE && type != G_AT_SERVER_REQUEST_TYPE_SUPPORT) { |
| g_at_server_send_final(h->em->server, G_AT_SERVER_RESULT_ERROR); |
| return; |
| } |
| |
| handler_proxy(server, type, result, userdata); |
| } |
| |
| static void handler_destroy(gpointer userdata) |
| { |
| struct handler *h = userdata; |
| |
| if (h->destroy) |
| h->destroy(h->data); |
| |
| g_free(h); |
| } |
| |
| ofono_bool_t ofono_emulator_add_handler(struct ofono_emulator *em, |
| const char *prefix, |
| ofono_emulator_request_cb_t cb, |
| void *data, ofono_destroy_func destroy) |
| { |
| struct handler *h; |
| GAtServerNotifyFunc func = handler_proxy; |
| |
| h = g_new0(struct handler, 1); |
| h->cb = cb; |
| h->data = data; |
| h->destroy = destroy; |
| h->em = em; |
| |
| if (em->type == OFONO_EMULATOR_TYPE_HFP) { |
| func = handler_proxy_need_slc; |
| |
| if (!strcmp(prefix, "+CHLD")) |
| func = handler_proxy_chld; |
| } |
| |
| if (g_at_server_register(em->server, prefix, func, h, |
| handler_destroy) == TRUE) |
| return TRUE; |
| |
| g_free(h); |
| |
| return FALSE; |
| } |
| |
| ofono_bool_t ofono_emulator_remove_handler(struct ofono_emulator *em, |
| const char *prefix) |
| { |
| return g_at_server_unregister(em->server, prefix); |
| } |
| |
| ofono_bool_t ofono_emulator_request_next_string( |
| struct ofono_emulator_request *req, |
| const char **str) |
| { |
| return g_at_result_iter_next_string(&req->iter, str); |
| } |
| |
| ofono_bool_t ofono_emulator_request_next_number( |
| struct ofono_emulator_request *req, |
| int *number) |
| { |
| return g_at_result_iter_next_number(&req->iter, number); |
| } |
| |
| const char *ofono_emulator_request_get_raw(struct ofono_emulator_request *req) |
| { |
| return g_at_result_iter_raw_line(&req->iter); |
| } |
| |
| enum ofono_emulator_request_type ofono_emulator_request_get_type( |
| struct ofono_emulator_request *req) |
| { |
| return req->type; |
| } |
| |
| void ofono_emulator_set_indicator(struct ofono_emulator *em, |
| const char *name, int value) |
| { |
| int i; |
| char buf[20]; |
| struct indicator *ind; |
| struct indicator *call_ind; |
| struct indicator *cs_ind; |
| gboolean call; |
| gboolean callsetup; |
| gboolean waiting; |
| |
| ind = find_indicator(em, name, &i); |
| |
| if (ind == NULL || ind->value == value || value < ind->min |
| || value > ind->max) |
| return; |
| |
| ind->value = value; |
| |
| call_ind = find_indicator(em, OFONO_EMULATOR_IND_CALL, NULL); |
| cs_ind = find_indicator(em, OFONO_EMULATOR_IND_CALLSETUP, NULL); |
| |
| call = ind == call_ind; |
| callsetup = ind == cs_ind; |
| |
| /* |
| * When callsetup indicator goes to Incoming and there is an active |
| * call a +CCWA should be sent before +CIEV |
| */ |
| waiting = (callsetup && value == OFONO_EMULATOR_CALLSETUP_INCOMING && |
| call_ind->value == OFONO_EMULATOR_CALL_ACTIVE); |
| |
| if (waiting) |
| notify_ccwa(em); |
| |
| if (em->events_mode == 3 && em->events_ind && em->slc && ind->active) { |
| if (!g_at_server_command_pending(em->server)) { |
| sprintf(buf, "+CIEV: %d,%d", i, ind->value); |
| g_at_server_send_unsolicited(em->server, buf); |
| } else |
| ind->deferred = TRUE; |
| } |
| |
| /* |
| * Ring timer should be started when: |
| * - callsetup indicator is set to Incoming and there is no active call |
| * (not a waiting call) |
| * - or call indicator is set to inactive while callsetup is already |
| * set to Incoming. |
| * In those cases, a first RING should be sent just after the +CIEV |
| * Ring timer should be stopped for all other values of callsetup |
| */ |
| if (waiting) |
| return; |
| |
| /* Call state went from active/held + waiting -> incoming */ |
| if (call && value == OFONO_EMULATOR_CALL_INACTIVE && |
| cs_ind->value == OFONO_EMULATOR_CALLSETUP_INCOMING) |
| goto start_ring; |
| |
| if (!callsetup) |
| return; |
| |
| if (value != OFONO_EMULATOR_CALLSETUP_INCOMING) { |
| if (em->callsetup_source > 0) { |
| g_source_remove(em->callsetup_source); |
| em->callsetup_source = 0; |
| } |
| |
| return; |
| } |
| |
| start_ring: |
| notify_ring(em); |
| em->callsetup_source = g_timeout_add_seconds(RING_TIMEOUT, |
| notify_ring, em); |
| } |
| |
| void __ofono_emulator_set_indicator_forced(struct ofono_emulator *em, |
| const char *name, int value) |
| { |
| int i; |
| struct indicator *ind; |
| char buf[20]; |
| |
| ind = find_indicator(em, name, &i); |
| |
| if (ind == NULL || value < ind->min || value > ind->max) |
| return; |
| |
| ind->value = value; |
| |
| if (em->events_mode == 3 && em->events_ind && em->slc && ind->active) { |
| if (!g_at_server_command_pending(em->server)) { |
| sprintf(buf, "+CIEV: %d,%d", i, ind->value); |
| g_at_server_send_unsolicited(em->server, buf); |
| } else |
| ind->deferred = TRUE; |
| } |
| } |
| |
| void __ofono_emulator_slc_condition(struct ofono_emulator *em, |
| enum ofono_emulator_slc_condition cond) |
| { |
| if (em->slc == TRUE) |
| return; |
| |
| switch (cond) { |
| case OFONO_EMULATOR_SLC_CONDITION_CMER: |
| if ((em->r_features & HFP_HF_FEATURE_3WAY) && |
| (em->l_features & HFP_AG_FEATURE_3WAY)) |
| return; |
| /* Fall Through */ |
| |
| case OFONO_EMULATOR_SLC_CONDITION_CHLD: |
| if ((em->r_features & HFP_HF_FEATURE_HF_INDICATORS) && |
| (em->l_features & HFP_HF_FEATURE_HF_INDICATORS)) |
| return; |
| /* Fall Through */ |
| |
| case OFONO_EMULATOR_SLC_CONDITION_BIND: |
| ofono_info("SLC reached"); |
| em->slc = TRUE; |
| |
| ofono_handsfree_card_register(em->card); |
| |
| default: |
| break; |
| } |
| } |
| |
| void ofono_emulator_set_hf_indicator_active(struct ofono_emulator *em, |
| int indicator, |
| ofono_bool_t active) |
| { |
| char buf[64]; |
| |
| if (!(em->l_features & HFP_HF_FEATURE_HF_INDICATORS)) |
| return; |
| |
| if (!(em->r_features & HFP_HF_FEATURE_HF_INDICATORS)) |
| return; |
| |
| if (indicator != HFP_HF_INDICATOR_ENHANCED_SAFETY) |
| return; |
| |
| em->ddr_active = active; |
| |
| sprintf(buf, "+BIND: %d,%d", HFP_HF_INDICATOR_ENHANCED_SAFETY, active); |
| g_at_server_send_unsolicited(em->server, buf); |
| } |
| |
| void ofono_emulator_set_handsfree_card(struct ofono_emulator *em, |
| struct ofono_handsfree_card *card) |
| { |
| if (em == NULL) |
| return; |
| |
| em->card = card; |
| } |
| |
| static unsigned char select_codec(struct ofono_emulator *em) |
| { |
| if (ofono_handsfree_audio_has_wideband() && |
| em->r_codecs[MSBC_OFFSET].supported) |
| return HFP_CODEC_MSBC; |
| |
| /* CVSD is mandatory for both sides */ |
| return HFP_CODEC_CVSD; |
| } |
| |
| int ofono_emulator_start_codec_negotiation(struct ofono_emulator *em, |
| ofono_emulator_codec_negotiation_cb cb, void *data) |
| { |
| char buf[64]; |
| unsigned char codec; |
| |
| if (em == NULL) |
| return -EINVAL; |
| |
| if (cb != NULL && em->codec_negotiation_cb != NULL) |
| return -EALREADY; |
| |
| if (em->proposed_codec > 0) |
| return -EALREADY; |
| |
| if (!em->bac_received || em->negotiated_codec > 0) { |
| /* |
| * Report we're done even if we don't have done any |
| * negotiation as the other side may have to clean up. |
| */ |
| cb(0, data); |
| |
| /* |
| * If we didn't received any +BAC during the SLC setup the |
| * remote side doesn't support codec negotiation and we can |
| * directly connect our card. Otherwise if we got +BAC and |
| * already have a negotiated codec we can proceed here |
| * without doing any negotiation again. |
| */ |
| ofono_handsfree_card_connect_sco(em->card); |
| |
| return 0; |
| } |
| |
| if (em->selected_codec > 0) { |
| codec = em->selected_codec; |
| em->selected_codec = 0; |
| goto done; |
| } |
| |
| codec = select_codec(em); |
| if (!codec) { |
| DBG("Failed to select HFP codec"); |
| return -EINVAL; |
| } |
| |
| done: |
| em->proposed_codec = codec; |
| |
| em->codec_negotiation_cb = cb; |
| em->codec_negotiation_data = data; |
| |
| snprintf(buf, 64, "+BCS: %d", em->proposed_codec); |
| g_at_server_send_unsolicited(em->server, buf); |
| |
| return 0; |
| } |