static void ril_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
int len = strlen(dtmf);
struct parcel rilp;
struct ofono_error error;
char *ril_dtmf = g_try_malloc(sizeof(char) * 2);
int i;
DBG("");
/* Ril wants just one character, but we need to send as string */
ril_dtmf[1] = '\0';
for (i = 0; i < len; i++) {
parcel_init(&rilp);
ril_dtmf[0] = dtmf[i];
parcel_w_string(&rilp, ril_dtmf);
DBG("DTMF: Sending %s", ril_dtmf);
g_ril_send(vd->ril, RIL_REQUEST_DTMF, rilp.data,
rilp.size, NULL, NULL, NULL);
parcel_free(&rilp);
}
free(ril_dtmf);
/* We don't really care about errors here */
decode_ril_error(&error, "OK");
cb(&error, data);
}
static void ril_dial(struct ofono_voicecall *vc,
const struct ofono_phone_number *ph,
enum ofono_clir_option clir, ofono_voicecall_cb_t cb,
void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int ret;
cbd->user = vc;
parcel_init(&rilp);
/* Number to dial */
parcel_w_string(&rilp, phone_number_to_string(ph));
/* CLIR mode */
parcel_w_int32(&rilp, clir);
/* USS, need it twice for absent */
/* TODO: Deal with USS properly */
parcel_w_int32(&rilp, 0);
parcel_w_int32(&rilp, 0);
/* Send request to RIL */
ret = g_ril_send(vd->ril, RIL_REQUEST_DIAL, rilp.data,
rilp.size, rild_cb, cbd, g_free);
parcel_free(&rilp);
/* In case of error free cbd and return the cb with failure */
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_hangup_all(struct ofono_voicecall *vc,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct parcel rilp;
struct ofono_error error;
struct ofono_call *call;
GSList *l;
for (l = vd->calls; l; l = l->next) {
call = l->data;
/* TODO: Hangup just the active ones once we have call
* state tracking (otherwise it can't handle ringing) */
DBG("Hanging up call with id %d", call->id);
parcel_init(&rilp);
parcel_w_int32(&rilp, 1); /* Always 1 - AT+CHLD=1x */
parcel_w_int32(&rilp, call->id);
/* Send request to RIL */
ril_template(RIL_REQUEST_HANGUP, vc, generic_cb, 0x3f,
rilp.data, rilp.size, NULL, NULL);
parcel_free(&rilp);
}
/* TODO: Deal in case of an error at hungup */
decode_ril_error(&error, "OK");
cb(&error, data);
}
static void ril_template(const guint rreq, struct ofono_voicecall *vc,
GRilResponseFunc func, unsigned int affected_types,
gpointer pdata, const gsize psize,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct change_state_req *req = g_try_new0(struct change_state_req, 1);
if (req == NULL)
goto error;
req->vc = vc;
req->cb = cb;
req->data = data;
req->affected_types = affected_types;
if (g_ril_send(vd->ril, rreq, pdata, psize, func, req, g_free) > 0)
return;
error:
g_free(req);
if (cb)
CALLBACK_WITH_FAILURE(cb, data);
}
static void generic_cb(struct ril_msg *message, gpointer user_data)
{
struct change_state_req *req = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(req->vc);
struct ofono_error error;
if (message->error == RIL_E_SUCCESS) {
decode_ril_error(&error, "OK");
} else {
decode_ril_error(&error, "FAIL");
goto out;
}
if (req->affected_types) {
GSList *l;
struct ofono_call *call;
for (l = vd->calls; l; l = l->next) {
call = l->data;
if (req->affected_types & (1 << call->status))
vd->local_release |= (1 << call->id);
}
}
out:
g_ril_send(vd->ril, RIL_REQUEST_GET_CURRENT_CALLS, NULL,
0, clcc_poll_cb, req->vc, NULL);
/* We have to callback after we schedule a poll if required */
if (req->cb)
req->cb(&error, req->data);
}
static gboolean poll_clcc(gpointer user_data)
{
struct ofono_voicecall *vc = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
g_ril_send(vd->ril, RIL_REQUEST_GET_CURRENT_CALLS, NULL,
0, clcc_poll_cb, vc, NULL);
vd->clcc_source = 0;
return FALSE;
}
static gboolean ril_delayed_register(gpointer user_data)
{
struct ofono_voicecall *vc = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
ofono_voicecall_register(vc);
/* Initialize call list */
poll_clcc(vc);
/* Unsol when call state changes */
g_ril_register(vd->ril, RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
ril_call_state_notify, vc);
/* This makes the timeout a single-shot */
return FALSE;
}
static void ril_voicecall_remove(struct ofono_voicecall *vc)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
if (vd->clcc_source)
g_source_remove(vd->clcc_source);
if (vd->vts_source)
g_source_remove(vd->vts_source);
g_slist_foreach(vd->calls, (GFunc) g_free, NULL);
g_slist_free(vd->calls);
ofono_voicecall_set_data(vc, NULL);
g_ril_unref(vd->ril);
g_free(vd);
}
static void rild_cb(struct ril_msg *message, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct ofono_voicecall *vc = cbd->user;
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
ofono_voicecall_cb_t cb = cbd->cb;
struct ofono_error error;
struct ofono_call *call;
GSList *l;
if (message->error == RIL_E_SUCCESS) {
decode_ril_error(&error, "OK");
} else {
decode_ril_error(&error, "FAIL");
goto out;
}
/* On a success, make sure to put all active calls on hold */
for (l = vd->calls; l; l = l->next) {
call = l->data;
if (call->status != CALL_STATUS_ACTIVE)
continue;
call->status = CALL_STATUS_HELD;
ofono_voicecall_notify(vc, call);
}
/* CLCC will update the oFono call list with proper ids */
if (!vd->clcc_source)
vd->clcc_source = g_timeout_add(POLL_CLCC_INTERVAL,
poll_clcc, vc);
audioflinger_set_call_mode();
out:
cb(&error, cbd->data);
}
static void clcc_poll_cb(struct ril_msg *message, gpointer user_data)
{
struct ofono_voicecall *vc = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
GSList *calls;
GSList *n, *o;
struct ofono_call *nc, *oc;
struct ofono_error error;
if (message->error != RIL_E_SUCCESS) {
ofono_error("We are polling CLCC and received an error");
ofono_error("All bets are off for call management");
return;
}
calls = ril_util_parse_clcc(vd->ril, message);
n = calls;
o = vd->calls;
while (n || o) {
nc = n ? n->data : NULL;
oc = o ? o->data : NULL;
if (oc && (nc == NULL || (nc->id > oc->id))) {
if (vd->local_release & (1 << oc->id)) {
ofono_voicecall_disconnected(vc, oc->id,
OFONO_DISCONNECT_REASON_LOCAL_HANGUP, NULL);
} else {
/* Get disconnect cause before informing oFono core */
struct lastcause_req *reqdata =
g_try_new0(struct lastcause_req, 1);
if (reqdata) {
reqdata->vc = user_data;
reqdata->id = oc->id;
g_ril_send(vd->ril, RIL_REQUEST_LAST_CALL_FAIL_CAUSE,
NULL, 0, lastcause_cb, reqdata, g_free);
}
}
clear_dtmf_queue(vd);
o = o->next;
} else if (nc && (oc == NULL || (nc->id < oc->id))) {
/* new call, signal it */
if (nc->type) {
ofono_voicecall_notify(vc, nc);
if (vd->cb) {
ofono_voicecall_cb_t cb = vd->cb;
decode_ril_error(&error, "OK");
cb(&error, vd->data);
vd->cb = NULL;
vd->data = NULL;
}
}
n = n->next;
} else {
/*
* Always use the clip_validity from old call
* the only place this is truly told to us is
* in the CLIP notify, the rest are fudged
* anyway. Useful when RING, CLIP is used,
* and we're forced to use CLCC and clip_validity
* is 1
*/
if (oc->clip_validity == 1)
nc->clip_validity = oc->clip_validity;
nc->cnap_validity = oc->cnap_validity;
/*
* CDIP doesn't arrive as part of CLCC, always
* re-use from the old call
*/
memcpy(&nc->called_number, &oc->called_number,
sizeof(oc->called_number));
/*
* If the CLIP is not provided and the CLIP never
* arrives, or RING is used, then signal the call
* here
*/
if (nc->status == CALL_STATUS_INCOMING &&
(vd->flags & FLAG_NEED_CLIP)) {
if (nc->type)
ofono_voicecall_notify(vc, nc);
vd->flags &= ~FLAG_NEED_CLIP;
} else if (memcmp(nc, oc, sizeof(*nc)) && nc->type)
ofono_voicecall_notify(vc, nc);
n = n->next;
o = o->next;
}
}
static void clcc_poll_cb(struct ril_msg *message, gpointer user_data)
{
struct ofono_voicecall *vc = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
GSList *calls;
GSList *n, *o;
struct ofono_call *nc, *oc;
if (message->error != RIL_E_SUCCESS) {
ofono_error("We are polling CLCC and received an error");
ofono_error("All bets are off for call management");
return;
}
calls = ril_util_parse_clcc(message);
n = calls;
o = vd->calls;
while (n || o) {
nc = n ? n->data : NULL;
oc = o ? o->data : NULL;
if (oc && (nc == NULL || (nc->id > oc->id))) {
enum ofono_disconnect_reason reason;
if (vd->local_release & (1 << oc->id))
reason = OFONO_DISCONNECT_REASON_LOCAL_HANGUP;
else
reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
if (oc->type)
ofono_voicecall_disconnected(vc, oc->id,
reason, NULL);
o = o->next;
} else if (nc && (oc == NULL || (nc->id < oc->id))) {
/* new call, signal it */
if (nc->type)
ofono_voicecall_notify(vc, nc);
n = n->next;
} else {
/*
* Always use the clip_validity from old call
* the only place this is truly told to us is
* in the CLIP notify, the rest are fudged
* anyway. Useful when RING, CLIP is used,
* and we're forced to use CLCC and clip_validity
* is 1
*/
if (oc->clip_validity == 1)
nc->clip_validity = oc->clip_validity;
nc->cnap_validity = oc->cnap_validity;
/*
* CDIP doesn't arrive as part of CLCC, always
* re-use from the old call
*/
memcpy(&nc->called_number, &oc->called_number,
sizeof(oc->called_number));
/*
* If the CLIP is not provided and the CLIP never
* arrives, or RING is used, then signal the call
* here
*/
if (nc->status == CALL_STATUS_INCOMING &&
(vd->flags & FLAG_NEED_CLIP)) {
if (nc->type)
ofono_voicecall_notify(vc, nc);
vd->flags &= ~FLAG_NEED_CLIP;
} else if (memcmp(nc, oc, sizeof(*nc)) && nc->type)
ofono_voicecall_notify(vc, nc);
n = n->next;
o = o->next;
}
}
/* No other calls, get audioflinger into normal state */
if (vd->calls && !calls) {
audioflinger_set_normal_mode();
}
g_slist_foreach(vd->calls, (GFunc) g_free, NULL);
g_slist_free(vd->calls);
vd->calls = calls;
vd->local_release = 0;
}
