static void
reply_to_call_manager_get_calls (ModemOface *_self,
ModemRequest *request,
GPtrArray *array,
GError const *error,
gpointer user_data)
{
ModemCallService *self = MODEM_CALL_SERVICE (_self);
DEBUG ("enter");
if (!error)
{
guint i;
for (i = 0; i < array->len; i++)
{
GValueArray *va = g_ptr_array_index (array, i);
char const *path = g_value_get_boxed (va->values + 0);
GHashTable *properties = g_value_get_boxed (va->values + 1);
modem_call_service_ensure_instance (self, path, properties);
}
}
modem_oface_check_connected (_self, request, error);
}
static void
on_user_connection (DBusGProxy *proxy,
gboolean attached,
ModemCallService *self)
{
DEBUG ("(%p, %d, %p): enter", proxy, attached, self);
MODEM_CALL_SERVICE (self)->priv->user_connection = attached;
g_signal_emit (self, signals[SIGNAL_USER_CONNECTION], 0,
attached);
}
static void
on_manager_call_added (DBusGProxy *proxy,
char const *path,
GHashTable *properties,
gpointer user_data)
{
ModemCallService *self = MODEM_CALL_SERVICE (user_data);
DEBUG ("%s", path);
modem_call_service_ensure_instance (self, path, properties);
}
ModemRequest *
modem_call_request_hangup_conference (ModemCallService *self,
ModemCallServiceReply *callback,
gpointer user_data)
{
RETURN_NULL_IF_NOT_VALID (self);
return modem_request (MODEM_CALL_SERVICE (self), DBUS_PROXY (self),
"HangupMultiparty",
modem_call_service_noparams_request_reply,
G_CALLBACK (callback), user_data,
G_TYPE_INVALID);
}
/**
* modem_call_service_swap_calls
* @self ModemCallService object
*
* Swaps active and held calls. 0 or more active calls become
* held, and 0 or more held calls become active.
*/
ModemRequest *
modem_call_service_swap_calls (ModemCallService *self,
ModemCallServiceReply callback,
gpointer user_data)
{
RETURN_NULL_IF_NOT_VALID (self);
DEBUG ("%s.%s", MODEM_OFACE_CALL_MANAGER, "SwapCalls");
return modem_request (MODEM_CALL_SERVICE (self), DBUS_PROXY (self),
"SwapCalls", modem_call_service_noparams_request_reply,
G_CALLBACK (callback), user_data,
G_TYPE_INVALID);
}
static void
on_manager_call_removed (DBusGProxy *proxy,
char const *path,
gpointer user_data)
{
DEBUG ("%s", path);
ModemCallService *self = MODEM_CALL_SERVICE (user_data);
ModemCallServicePrivate *priv = self->priv;
ModemCall *ci = g_hash_table_lookup (priv->instances, path);
if (ci)
{
modem_call_service_disconnect_instance (self, ci);
}
}
static void
ring_media_manager_set_call_service (RingMediaManager *self,
ModemCallService *service)
{
RingMediaManagerPrivate *priv = self->priv;
if (priv->call_service)
{
ring_media_manager_disconnect (self);
}
if (service)
{
priv->call_service = g_object_ref (MODEM_CALL_SERVICE (service));
ring_media_manager_connected (self);
}
}
static void
modem_call_service_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
ModemCallService *self = MODEM_CALL_SERVICE (object);
switch (property_id)
{
case PROP_EMERGENCY_NUMBERS:
g_value_set_boxed (value, modem_call_get_emergency_numbers (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/** Disconnect from call service */
static void
modem_call_service_disconnect (ModemOface *_self)
{
DEBUG ("(%p): enter", _self);
ModemCallService *self = MODEM_CALL_SERVICE (_self);
ModemCallServicePrivate *priv = self->priv;
GHashTableIter iter[1];
ModemCall *ci;
while (!g_queue_is_empty (priv->dialing.queue))
{
ModemRequest *request = g_queue_pop_head (priv->dialing.queue);
modem_request_cancel (request);
}
if (priv->signals)
{
priv->signals = FALSE;
dbus_g_proxy_disconnect_signal (DBUS_PROXY (self), "CallAdded",
G_CALLBACK (on_manager_call_added), self);
dbus_g_proxy_disconnect_signal (DBUS_PROXY (self), "CallRemoved",
G_CALLBACK (on_manager_call_removed), self);
dbus_g_proxy_disconnect_signal (DBUS_PROXY (self), "Forwarded",
G_CALLBACK (on_manager_call_forwarded), self);
}
for (g_hash_table_iter_init (iter, priv->instances);
g_hash_table_iter_next (iter, NULL, (gpointer)&ci);
g_hash_table_iter_init (iter, priv->instances))
{
modem_call_service_disconnect_instance (self, ci);
}
ci = priv->conference.instance;
modem_call_service_disconnect_instance (self, ci);
modem_oface_disconnect_properties (_self);
}
static void
modem_call_service_finalize (GObject *object)
{
DEBUG ("enter");
ModemCallService *self = MODEM_CALL_SERVICE (object);
ModemCallServicePrivate *priv = self->priv;
if (priv->forwarded)
{
g_free(priv->forwarded);
priv->forwarded = NULL;
}
g_strfreev (priv->emergency_numbers), priv->emergency_numbers = NULL;
g_hash_table_destroy (priv->instances);
G_OBJECT_CLASS (modem_call_service_parent_class)->finalize (object);
DEBUG ("leave");
}
static void
on_manager_call_forwarded (DBusGProxy *proxy,
char const *type,
gpointer user_data)
{
DEBUG ("%s", type);
ModemCallService *self = MODEM_CALL_SERVICE (user_data);
ModemCall *ci = NULL;
GHashTableIter iter[1];
g_hash_table_iter_init (iter, self->priv->instances);
while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci))
{
ModemCallState state;
g_object_get (ci, "state", &state, NULL);
if (state == MODEM_CALL_STATE_INCOMING && strcmp(type, "incoming") == 0)
{
break;
}
else if (state == MODEM_CALL_STATE_DIALING && strcmp(type, "outgoing") == 0)
{
break;
}
}
if (ci)
{
g_signal_emit_by_name (ci, "forwarded");
}
else
{
self->priv->forwarded = g_strdup(type);
}
}
/** Connect to call service */
static void
modem_call_service_connect (ModemOface *_self)
{
DEBUG ("(%p): enter", _self);
ModemCallService *self = MODEM_CALL_SERVICE (_self);
ModemCallServicePrivate *priv = self->priv;
if (!priv->signals)
{
DBusGProxy *proxy = DBUS_PROXY (_self);
priv->signals = TRUE;
#define CONNECT(p, handler, name, signature...) \
dbus_g_proxy_add_signal (p, (name), ##signature); \
dbus_g_proxy_connect_signal (p, (name), G_CALLBACK (handler), self, NULL)
CONNECT (proxy, on_manager_call_added, "CallAdded",
DBUS_TYPE_G_OBJECT_PATH, MODEM_TYPE_DBUS_DICT, G_TYPE_INVALID);
CONNECT (proxy, on_manager_call_removed, "CallRemoved",
DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
CONNECT (proxy, on_manager_call_forwarded, "Forwarded",
G_TYPE_STRING, G_TYPE_INVALID);
#undef CONNECT
}
modem_oface_connect_properties (_self, TRUE);
modem_oface_add_connect_request (_self,
modem_oface_request_managed (_self, "GetCalls",
reply_to_call_manager_get_calls, NULL));
}
static void
modem_call_service_set_property (GObject *obj,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
ModemCallService *self = MODEM_CALL_SERVICE (obj);
ModemCallServicePrivate *priv = self->priv;
gpointer old;
switch (property_id)
{
case PROP_EMERGENCY_NUMBERS:
old = priv->emergency_numbers;
priv->emergency_numbers = g_value_dup_boxed (value);
g_strfreev (old);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
break;
}
}
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);
}
