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); } }
static void on_modem_call_incoming(ModemCallService *call_service, ModemCall *modem_call, char const *originator, RingMediaManager *self) { RingMediaManagerPrivate *priv = self->priv; TpHandleRepoIface *repo; RingCallChannel *channel; TpHandle handle; GError *error = NULL; if (!ring_media_manager_is_connected (self)) return; channel = modem_call_get_handler(modem_call); if (channel) { modem_call_set_handler(modem_call, NULL); ring_critical("Call instance %s already associated with channel.", modem_call_get_name(modem_call)); ring_critical("Closing old channel %s.", RING_MEDIA_CHANNEL(channel)->nick); ring_media_channel_close(RING_MEDIA_CHANNEL(channel)); } repo = tp_base_connection_get_handles( (TpBaseConnection *)(self->priv->connection), TP_HANDLE_TYPE_CONTACT); error = NULL; handle = tp_handle_ensure(repo, originator, ring_network_normalization_context(), &error); if (handle == 0) { DEBUG("tp_handle_ensure:" GERROR_MSG_FMT, GERROR_MSG_CODE(error)); if (error) g_error_free(error); /* Xyzzy - modem_call_request_release() ?? */ return; } /* Incoming call - pass call and handle ownership to new media channel */ char *object_path = ring_media_manager_new_object_path(self, "incoming"); channel = (RingCallChannel *) g_object_new(RING_TYPE_CALL_CHANNEL, "connection", priv->connection, "tones", priv->tones, "object-path", object_path, "initiator-handle", handle, "handle-type", TP_HANDLE_TYPE_CONTACT, "handle", handle, "peer", handle, "requested", FALSE, "initial-audio", TRUE, "anon-modes", priv->anon_modes, "call-instance", modem_call, "terminating", TRUE, NULL); g_free(object_path); ring_media_manager_emit_new_channel(self, NULL, channel, NULL); ring_media_channel_set_state(RING_MEDIA_CHANNEL(channel), MODEM_CALL_STATE_INCOMING, 0, 0); }
static void on_modem_call_created(ModemCallService *call_service, ModemCall *modem_call, char const *destination, RingMediaManager *self) { RingMediaManagerPrivate *priv = self->priv; TpHandleRepoIface *repo; RingCallChannel *channel; TpHandle handle; char const *sos; GError *error = NULL; if (!ring_media_manager_is_connected (self)) return; channel = modem_call_get_handler(modem_call); if (channel) return; /* Call created by ring, nothing to do */ /* This is a call created outside ring, create a channel for it */ DEBUG("Freshly created call instance %s not associated with channel.", modem_call_get_name(modem_call)); repo = tp_base_connection_get_handles( (TpBaseConnection *)(self->priv->connection), TP_HANDLE_TYPE_CONTACT); error = NULL; handle = tp_handle_ensure(repo, destination, ring_network_normalization_context(), &error); if (handle == 0) { ring_warning("tp_handle_ensure:" GERROR_MSG_FMT, GERROR_MSG_CODE(error)); if (error) g_error_free(error); /* Xyzzy - modem_call_request_release() ?? */ return; } sos = modem_call_get_emergency_service(priv->call_service, destination); char *object_path = ring_media_manager_new_object_path(self, "created"); channel = (RingCallChannel *) g_object_new(RING_TYPE_CALL_CHANNEL, "connection", priv->connection, "tones", priv->tones, "object-path", object_path, "initiator-handle", tp_base_connection_get_self_handle( TP_BASE_CONNECTION(priv->connection)), "handle-type", TP_HANDLE_TYPE_CONTACT, "handle", handle, "peer", handle, "requested", TRUE, "initial-remote", handle, "initial-audio", TRUE, "anon-modes", priv->anon_modes, "call-instance", modem_call, "originating", TRUE, sos ? "initial-emergency-service" : NULL, sos, NULL); g_free(object_path); ring_media_manager_emit_new_channel(self, NULL, channel, NULL); ring_media_channel_set_state(RING_MEDIA_CHANNEL(channel), MODEM_CALL_STATE_DIALING, 0, 0); }
static ModemCall * modem_call_service_ensure_instance (ModemCallService *self, char const *object_path, GHashTable *properties) { ModemCallServicePrivate *priv = self->priv; char *key; GValue *value; GHashTableIter iter[1]; gchar const *remote; ModemCallState state; gboolean incoming = FALSE, originating = FALSE; ModemCall *ci; DEBUG ("path %s", object_path); if (DEBUGGING) { for (g_hash_table_iter_init (iter, properties); g_hash_table_iter_next (iter, (gpointer)&key, (gpointer)&value);) { char *s = g_strdup_value_contents (value); DEBUG ("%s = %s", key, s); g_free (s); } } ci = g_hash_table_lookup (priv->instances, object_path); if (ci) { DEBUG ("call already exists %p", (void *)ci); return ci; } value = g_hash_table_lookup (properties, "LineIdentification"); remote = g_value_get_string (value); value = g_hash_table_lookup (properties, "State"); state = modem_call_state_from_ofono_state (g_value_get_string (value)); switch (state) { case MODEM_CALL_STATE_INCOMING: case MODEM_CALL_STATE_WAITING: incoming = TRUE; originating = FALSE; break; case MODEM_CALL_STATE_DIALING: case MODEM_CALL_STATE_ALERTING: case MODEM_CALL_STATE_ACTIVE: case MODEM_CALL_STATE_HELD: incoming = FALSE; originating = TRUE; break; case MODEM_CALL_STATE_INVALID: case MODEM_CALL_STATE_DISCONNECTED: DEBUG ("call already in invalid state"); return NULL; } ci = g_object_new (MODEM_TYPE_CALL, "object-path", object_path, "call-service", self, "state", state, "terminating", !originating, "originating", originating, NULL); modem_oface_update_properties (MODEM_OFACE (ci), properties); modem_call_service_connect_to_instance (self, ci); if (incoming) { DEBUG ("emit \"incoming\" (\"%s\" (%p), \"%s\")", modem_call_get_name (ci), ci, remote); g_signal_emit (self, signals[SIGNAL_INCOMING], 0, ci, remote); if (priv->forwarded && !strcmp(priv->forwarded, "incoming")) { g_signal_emit_by_name (ci, "forwarded"); } } else if (g_queue_is_empty (priv->dialing.queue)) { DEBUG ("emit \"created\" (\"%s\" (%p), \"%s\")", modem_call_get_name (ci), ci, remote); g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote); if (priv->forwarded && !strcmp(priv->forwarded, "outgoing")) { g_signal_emit_by_name (ci, "forwarded"); } } else { g_queue_push_tail (priv->dialing.created, ci); } if (priv->forwarded) { g_free(priv->forwarded); priv->forwarded = NULL; } return ci; }