static void
on_sms_service_deliver(ModemSMSService *sms_service,
SMSGDeliver *deliver,
gpointer _self)
{
ring_text_manager_receive_deliver(RING_TEXT_MANAGER(_self), deliver);
}
static void
ring_text_manager_get_property(GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
RingTextManager *self = RING_TEXT_MANAGER(object);
RingTextManagerPrivate *priv = self->priv;
switch (property_id) {
case PROP_CONNECTION:
g_value_set_object(value, priv->connection);
break;
case PROP_SMS_SERVICE:
g_value_set_pointer (value, priv->sms_service);
break;
case PROP_SMSC:
g_value_set_string(value, priv->smsc ? priv->smsc : "");
break;
case PROP_SMS_VALID:
g_value_set_uint(value, priv->sms_valid);
break;
case PROP_SMS_REDUCED_CHARSET:
g_value_set_boolean(value, priv->sms_reduced_charset);
break;
case PROP_CAPABILITY_FLAGS:
g_value_set_uint(value, priv->capability_flags);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
}
}
static gboolean
ring_text_manager_ensure_channel(TpChannelManager *_self,
gpointer request,
GHashTable *properties)
{
return ring_text_requestotron(RING_TEXT_MANAGER(_self), request, properties, 0);
}
void
ring_text_manager_add_capabilities(RingTextManager *self,
guint handle,
GPtrArray *returns)
{
RingTextManagerPrivate *priv = RING_TEXT_MANAGER(self)->priv;
char const *id = ring_connection_inspect_contact(priv->connection, handle);
guint selfhandle = tp_base_connection_get_self_handle(
(TpBaseConnection *)priv->connection);
char *destination;
if (id == NULL)
return;
/* Some UIs create channels even if they do not intend to send anything */
/* Allow them to do so */
destination = ring_text_channel_destination(id);
if (handle == selfhandle || modem_sms_is_valid_address (destination)) {
g_ptr_array_add(returns,
ring_contact_capability_new(handle,
TP_IFACE_CHANNEL_TYPE_TEXT,
TP_CONNECTION_CAPABILITY_FLAG_CREATE,
RING_TEXT_CHANNEL_CAPABILITY_FLAGS));
}
g_free(destination);
}
static void
on_sms_service_status_report(ModemSMSService *sms_service,
SMSGStatusReport *status_report,
gpointer _self)
{
ring_text_manager_receive_status_report(
RING_TEXT_MANAGER(_self), status_report);
}
static void
on_sms_service_status_report(ModemSMSService *sms_service,
char const *destination,
char const *token,
gboolean const *success,
gpointer _self)
{
ring_text_manager_receive_status_report(
RING_TEXT_MANAGER(_self), destination, token, success);
}
static void
ring_text_manager_finalize(GObject *object)
{
RingTextManager *self = RING_TEXT_MANAGER(object);
RingTextManagerPrivate *priv = self->priv;
/* Free any data held directly by the object here */
g_free(priv->smsc);
g_hash_table_destroy (priv->channels);
G_OBJECT_CLASS(ring_text_manager_parent_class)->finalize(object);
}
static void
ring_text_manager_constructed(GObject *object)
{
RingTextManager *self = RING_TEXT_MANAGER(object);
RingTextManagerPrivate *priv = self->priv;
priv->signals.status_changed = g_signal_connect (priv->connection,
"status-changed", (GCallback) on_connection_status_changed, self);
if (G_OBJECT_CLASS(ring_text_manager_parent_class)->constructed)
G_OBJECT_CLASS(ring_text_manager_parent_class)->constructed(object);
}
static void
ring_text_manager_foreach_channel(TpChannelManager *_self,
TpExportableChannelFunc func,
gpointer user_data)
{
RingTextManager *self = RING_TEXT_MANAGER(_self);
GHashTableIter i[1];
gpointer channel;
for (g_hash_table_iter_init(i, self->priv->channels);
g_hash_table_iter_next(i, NULL, &channel);)
func(channel, user_data);
}
static void
ring_text_manager_dispose(GObject *object)
{
RingTextManager *self = RING_TEXT_MANAGER(object);
RingTextManagerPrivate *priv = self->priv;
ring_signal_disconnect (priv->connection, &priv->signals.status_changed);
ring_text_manager_disconnect (self);
g_hash_table_foreach (priv->channels, foreach_dispose, NULL);
g_hash_table_remove_all (priv->channels);
G_OBJECT_CLASS(ring_text_manager_parent_class)->dispose(object);
}
static void
ring_text_manager_set_property(GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
RingTextManager *self = RING_TEXT_MANAGER(object);
RingTextManagerPrivate *priv = self->priv;
switch (property_id) {
case PROP_CONNECTION:
/* We don't ref the connection, because it owns a reference to the
* manager, and it guarantees that the manager's lifetime is
* less than its lifetime */
priv->connection = g_value_get_object(value);
break;
case PROP_SMS_SERVICE:
ring_text_manager_set_sms_service (self, g_value_get_pointer (value));
break;
case PROP_SMSC:
priv->smsc = g_value_dup_string(value);
if (priv->sms_service)
g_object_set(priv->sms_service, "service-centre", priv->smsc, NULL);
break;
case PROP_SMS_VALID:
priv->sms_valid = g_value_get_uint(value);
if (priv->sms_service)
g_object_set(priv->sms_service, "validity-period", priv->sms_valid, NULL);
break;
case PROP_SMS_REDUCED_CHARSET:
priv->sms_reduced_charset = g_value_get_boolean(value);
if (priv->sms_service)
g_object_set(priv->sms_service, "reduced-charset",
priv->sms_reduced_charset, NULL);
break;
case PROP_CAPABILITY_FLAGS:
priv->capability_flags = g_value_get_uint(value) &
RING_TEXT_CHANNEL_CAPABILITY_FLAGS;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
}
}
static void
on_immediate_message (ModemSMSService *sms,
gchar const *message,
GHashTable *info,
gpointer _self)
{
RingTextManager *self = RING_TEXT_MANAGER (_self);
char const *sender;
RingTextChannel *channel;
g_return_if_fail (info != NULL);
g_return_if_fail (message != NULL);
sender = tp_asv_get_string (info, "Sender");
g_return_if_fail (sender != NULL);
channel = get_text_channel (self, sender, 0, 0);
g_return_if_fail (channel != NULL);
receive_text (self, channel, message, info, 0);
}
