void modem_call_service_resume (ModemCallService *self) { GHashTableIter iter[1]; ModemCall *ci; DEBUG ("enter"); RETURN_IF_NOT_VALID (self); /* XXX/KV: no such signal */ #if 0 g_signal_emit (self, signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED], 0, modem_call_get_emergency_numbers (self)); #endif g_hash_table_iter_init (iter, self->priv->instances); while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci)) { char *remote; gboolean terminating = FALSE; ModemCallState state; g_object_get (ci, "state", &state, "remote", &remote, "terminating", &terminating, NULL); if (state != MODEM_CALL_STATE_DISCONNECTED && state != MODEM_CALL_STATE_INVALID) { /* XXX - atm the value of 'terminating' cannot be trusted. * oFono should probably provide the direction as a property * since we cannot rely on the call state here. */ if (terminating) { modem_message (MODEM_LOG_CALL, "incoming [with state %s] call from \"%s\"", modem_call_get_state_name (state), remote); DEBUG ("emit \"incoming\"(%s (%p), %s)", modem_call_get_name (ci), ci, remote); g_signal_emit (self, signals[SIGNAL_INCOMING], 0, ci, remote); } else { modem_message (MODEM_LOG_CALL, "created [with state %s] call to \"%s\"", modem_call_get_state_name (state), remote); DEBUG ("emit \"created\"(%s (%p), %s)", modem_call_get_name (ci), ci, remote); g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote); } g_signal_emit_by_name (ci, "state", state, 0, 0); } g_free (remote); } }
ModemRequest * modem_call_request_dial (ModemCallService *self, char const *destination, ModemClirOverride clir, ModemCallRequestDialReply callback, gpointer user_data) { char const *clir_str; ModemRequest *request; ModemCallServicePrivate *priv = self->priv; DEBUG ("called"); RETURN_NULL_IF_NOT_VALID (self); g_return_val_if_fail (destination != NULL, NULL); g_return_val_if_fail (callback != NULL, NULL); modem_message (MODEM_LOG_CALL, "trying to create call to \"%s\"", destination); if (clir == MODEM_CLIR_OVERRIDE_DISABLED) clir_str = "disabled"; else if (clir == MODEM_CLIR_OVERRIDE_ENABLED) clir_str = "enabled"; else clir_str = ""; request = modem_request_begin (self, DBUS_PROXY (self), "Dial", modem_call_request_dial_reply, G_CALLBACK (callback), user_data, G_TYPE_STRING, destination, G_TYPE_STRING, clir_str, G_TYPE_INVALID); modem_request_add_cancel_notify (request, request_notify_cancel); modem_request_add_data_full (request, "call-destination", g_strdup (destination), g_free); g_queue_push_tail (priv->dialing.queue, request); return request; }
static void on_incoming_message (DBusGProxy *proxy, char const *message, GHashTable *dict, gpointer _self) { char const *smsc = "1234567"; char const *type = "text/plain"; char const *originator = ""; char *token; GError *error = NULL; GValue *value; SMSGDeliver *d; ModemSMSService *self = MODEM_SMS_SERVICE (_self); DEBUG ("message = \"%s\"", message); dump_message_dict (dict); value = g_hash_table_lookup (dict, "Sender"); if (value) originator = g_value_get_string (value); token = modem_sms_generate_token (); d = sms_g_deliver_incoming (message, token, originator, smsc, type, NULL, &error); if (!d) { modem_message (MODEM_LOG_SMS, "deserializing SMS-DELIVER \"%s\" failed: " GERROR_MSG_FMT, token, GERROR_MSG_CODE (error)); g_clear_error (&error); } else { modem_sms_incoming_deliver (self, d); g_object_unref (d); } g_free (token); }
static void modem_call_request_dial_reply (DBusGProxy *proxy, DBusGProxyCall *call, void *_request) { DEBUG ("enter"); ModemRequest *request = _request; ModemCallService *self = MODEM_CALL_SERVICE (modem_request_object (request)); ModemCallServicePrivate *priv = self->priv; ModemCallRequestDialReply *callback = modem_request_callback (request); gpointer user_data = modem_request_user_data (request); char *destination = modem_request_get_data (request, "call-destination"); GError *error = NULL; ModemCall *ci = NULL; char *object_path = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &object_path, G_TYPE_INVALID)) { ci = modem_call_service_get_dialed (self, object_path, destination); } else { object_path = NULL; modem_error_fix (&error); } if (ci) { DEBUG ("%s: instance %s (%p)", MODEM_OFACE_CALL_MANAGER ".Dial", object_path, (void *)ci); modem_message (MODEM_LOG_CALL, "call create request to \"%s\" successful", destination); } else { char ebuffer[32]; modem_message (MODEM_LOG_CALL, "call create request to \"%s\" failed: %s.%s: %s", destination, modem_error_domain_prefix (error->domain), modem_error_name (error, ebuffer, sizeof ebuffer), error->message); DEBUG ("%s: " GERROR_MSG_FMT, MODEM_OFACE_CALL_MANAGER ".Dial", GERROR_MSG_CODE (error)); } if (modem_request_get_data (request, "call-canceled")) { if (ci) modem_call_request_release (ci, NULL, NULL); } else { g_assert (ci || error); callback (self, request, ci, error, user_data); } if (g_queue_find (priv->dialing.queue, request)) g_queue_remove (priv->dialing.queue, request); while (g_queue_is_empty (priv->dialing.queue) && !g_queue_is_empty (priv->dialing.created)) { char *remote; ci = g_queue_pop_head (priv->dialing.created); g_object_get (ci, "remote", &remote, NULL); g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote); g_free (remote); } g_free (object_path); g_clear_error (&error); }
static void on_modem_call_state (ModemCall *ci, ModemCallState state, ModemCallService *self) { ModemCallServicePrivate *priv; gboolean releasing = FALSE; RETURN_IF_NOT_VALID (self); priv = self->priv; switch (state) { case MODEM_CALL_STATE_ACTIVE: if (priv->hold == ci) priv->hold = NULL; if (!modem_call_is_member (ci)) priv->active = ci; break; case MODEM_CALL_STATE_HELD: if (priv->active == ci) priv->active = NULL; if (!modem_call_is_member (ci)) priv->hold = ci; break; case MODEM_CALL_STATE_DISCONNECTED: releasing = TRUE; /* FALLTHROUGH */ case MODEM_CALL_STATE_INVALID: if (priv->active == ci) priv->active = NULL; if (priv->hold == ci) priv->hold = NULL; break; default: break; } #if nomore if (releasing) { GError *error = modem_call_new_error (causetype, cause, NULL); gboolean originating; char *remote; char const *what; g_object_get (ci, "originating", &originating, "remote", &remote, NULL); switch (state) { case MODEM_CALL_STATE_MO_RELEASE: what = "mo-released"; break; case MODEM_CALL_STATE_MT_RELEASE: what = "mt-released"; break; default: what = "terminated"; } gboolean mpty = MODEM_IS_CALL_CONFERENCE (ci); modem_message (MODEM_LOG_CALL, "%s %s %s%s%s %s.%s: %s", what, mpty ? "conference" : originating ? "outgoing call to" : "incoming call from", mpty ? "" : "'", mpty ? "call" : remote, mpty ? "" : "'", modem_error_domain_prefix (error->domain), modem_error_name (error, NULL, 0), error->message); g_free (remote); g_error_free (error); } #endif }