1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/calls.git synced 2024-11-16 05:15:36 +00:00
Purism-Calls/plugins/mm/calls-mm-origin.c
Bob Ham 460c0c6c3d Turn providers into plugins courtesy of libpeas
This is an initial, static implementation of plugins.  The
CallsApplication has a plugin name which can be changed with a new
--provider command line option.  This plugin name is used to
instantiate the appropriate plugin when the application is activated.
From then on, the plugin cannot change.

In future, we can expand this support to include loading multiple
plugins at once, configurable through some UI.  This will have
far-reaching implications though, and complicate things like
enumerating the provider hierarchy.  There is also no practical
benefit right now; the mm and ofono plugins can't be used at the same
time because ModemManager and oFono don't play nice together, and the
whole raison d'être of the dummy plugin is undermined if you can make
use of one of the others.  So for now, we just implement one static
plugin.
2018-11-23 15:51:46 +00:00

548 lines
12 KiB
C

/*
* Copyright (C) 2018 Purism SPC
*
* This file is part of Calls.
*
* Calls is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calls is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Calls. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Bob Ham <bob.ham@puri.sm>
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
#include "calls-mm-origin.h"
#include "calls-origin.h"
#include "calls-mm-call.h"
#include "calls-message-source.h"
#include <glib/gi18n.h>
struct _CallsMMOrigin
{
GObject parent_instance;
MMObject *mm_obj;
MMModemVoice *voice;
gchar *name;
GHashTable *calls;
};
static void calls_mm_origin_message_source_interface_init (CallsOriginInterface *iface);
static void calls_mm_origin_origin_interface_init (CallsOriginInterface *iface);
G_DEFINE_TYPE_WITH_CODE (CallsMMOrigin, calls_mm_origin, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (CALLS_TYPE_MESSAGE_SOURCE,
calls_mm_origin_message_source_interface_init)
G_IMPLEMENT_INTERFACE (CALLS_TYPE_ORIGIN,
calls_mm_origin_origin_interface_init))
enum {
PROP_0,
PROP_MODEM,
PROP_LAST_PROP,
};
static GParamSpec *props[PROP_LAST_PROP];
static const gchar *
get_name (CallsOrigin *origin)
{
CallsMMOrigin *self = CALLS_MM_ORIGIN (origin);
return self->name;
}
static GList *
get_calls (CallsOrigin * origin)
{
CallsMMOrigin *self = CALLS_MM_ORIGIN (origin);
return g_hash_table_get_values (self->calls);
}
static void
dial_cb (MMModemVoice *voice,
GAsyncResult *res,
CallsMMOrigin *self)
{
MMCall *call;
GError *error = NULL;
call = mm_modem_voice_create_call_finish (voice, res, &error);
if (!call)
{
g_warning ("Error dialing number on ModemManager modem `%s': %s",
self->name, error->message);
CALLS_ERROR (self, error);
}
}
static void
dial (CallsOrigin *origin, const gchar *number)
{
CallsMMOrigin *self = CALLS_MM_ORIGIN (origin);
MMCallProperties *props;
g_assert (self->voice != NULL);
props = mm_call_properties_new();
mm_call_properties_set_number (props, number);
mm_modem_voice_create_call
(self->voice,
props,
NULL,
(GAsyncReadyCallback) dial_cb,
self);
g_object_unref (props);
}
static void
remove_call (CallsMMOrigin *self,
CallsMMCall *call,
const gchar *path,
const gchar *reason)
{
g_signal_emit_by_name (CALLS_ORIGIN(self), "call-removed",
CALLS_CALL(call), reason);
g_hash_table_remove (self->calls, path);
}
struct CallsMMRemoveCallsData
{
CallsOrigin *origin;
const gchar *reason;
};
static gboolean
remove_calls_cb (const gchar *path,
CallsMMCall *call,
struct CallsMMRemoveCallsData *data)
{
g_signal_emit_by_name (data->origin, "call-removed",
CALLS_CALL(call), data->reason);
return TRUE;
}
static void
remove_calls (CallsMMOrigin *self, const gchar *reason)
{
struct CallsMMRemoveCallsData data = { CALLS_ORIGIN (self), reason };
g_hash_table_foreach_remove (self->calls,
(GHRFunc) remove_calls_cb,
&data);
}
struct CallsMMOriginDeleteCallData
{
CallsMMOrigin *self;
gchar *path;
};
static void
delete_call_cb (MMModemVoice *voice,
GAsyncResult *res,
struct CallsMMOriginDeleteCallData *data)
{
gboolean ok;
GError *error = NULL;
ok = mm_modem_voice_delete_call_finish (voice, res, &error);
if (!ok)
{
g_warning ("Error deleting call `%s' on MMModemVoice `%s': %s",
data->path, data->self->name, error->message);
CALLS_ERROR (data->self, error);
}
g_free (data->path);
g_free (data);
}
static void
delete_call (CallsMMOrigin *self,
CallsMMCall *call)
{
const gchar *path;
struct CallsMMOriginDeleteCallData *data;
path = calls_mm_call_get_object_path (call);
data = g_new0 (struct CallsMMOriginDeleteCallData, 1);
data->self = self;
data->path = g_strdup (path);
mm_modem_voice_delete_call
(self->voice,
path,
NULL,
(GAsyncReadyCallback)delete_call_cb,
data);
}
static void
call_state_changed_cb (CallsMMOrigin *self,
CallsCallState new_state,
CallsCallState old_state,
CallsCall *call)
{
if (new_state != CALLS_CALL_STATE_DISCONNECTED)
{
return;
}
delete_call (self, CALLS_MM_CALL (call));
}
static void
add_call (CallsMMOrigin *self,
MMCall *mm_call)
{
CallsMMCall *call;
gchar *path;
call = calls_mm_call_new (mm_call);
g_signal_connect_swapped (call, "state-changed",
G_CALLBACK (call_state_changed_cb),
self);
path = mm_call_dup_path (mm_call);
g_hash_table_insert (self->calls, path, call);
g_signal_emit_by_name (CALLS_ORIGIN(self), "call-added",
CALLS_CALL(call));
if (mm_call_get_state (mm_call) == MM_CALL_STATE_TERMINATED)
{
// Delete any remnant disconnected call
delete_call (self, call);
}
g_debug ("Call `%s' added", path);
}
struct CallsMMOriginCallAddedData
{
CallsMMOrigin *self;
gchar *path;
};
static void
call_added_list_calls_cb (MMModemVoice *voice,
GAsyncResult *res,
struct CallsMMOriginCallAddedData *data)
{
GList *calls;
GError *error = NULL;
calls = mm_modem_voice_list_calls_finish (voice, res, &error);
if (!calls)
{
if (error)
{
g_warning ("Error listing calls on MMModemVoice `%s'"
" after call-added signal: %s",
data->self->name, error->message);
CALLS_ERROR (data->self, error);
}
else
{
g_warning ("No calls on MMModemVoice `%s'"
" after call-added signal",
data->self->name);
}
}
else
{
GList *node;
MMCall *call;
gboolean found = FALSE;
for (node = calls; node; node = node->next)
{
call = MM_CALL (node->data);
if (g_strcmp0 (mm_call_get_path (call), data->path) == 0)
{
add_call (data->self, call);
found = TRUE;
}
}
if (!found)
{
g_warning ("Could not find new call `%s' in call list"
" on MMModemVoice `%s' after call-added signal",
data->path, data->self->name);
}
g_list_free_full (calls, g_object_unref);
}
g_free (data->path);
g_free (data);
}
static void
call_added_cb (MMModemVoice *voice,
gchar *path,
CallsMMOrigin *self)
{
struct CallsMMOriginCallAddedData *data;
if (g_hash_table_contains (self->calls, path))
{
g_warning ("Received call-added signal for"
" existing call object path `%s'", path);
return;
}
data = g_new0 (struct CallsMMOriginCallAddedData, 1);
data->self = self;
data->path = g_strdup (path);
mm_modem_voice_list_calls
(voice,
NULL,
(GAsyncReadyCallback) call_added_list_calls_cb,
data);
}
static void
call_deleted_cb (MMModemVoice *voice,
const gchar *path,
CallsMMOrigin *self)
{
CallsMMCall *call;
GString *reason;
const gchar *mm_reason;
g_debug ("Removing call `%s'", path);
call = g_hash_table_lookup (self->calls, path);
if (!call)
{
g_warning ("Could not find removed call `%s'", path);
return;
}
reason = g_string_new ("Call removed");
mm_reason = calls_mm_call_get_disconnect_reason (call);
if (mm_reason)
{
g_string_assign (reason, mm_reason);
}
remove_call (self, call, path, reason->str);
g_string_free (reason, TRUE);
g_debug ("Removed call `%s'", path);
}
static void
list_calls_cb (MMModemVoice *voice,
GAsyncResult *res,
CallsMMOrigin *self)
{
GList *calls, *node;
GError *error = NULL;
calls = mm_modem_voice_list_calls_finish (voice, res, &error);
if (!calls)
{
if (error)
{
g_warning ("Error listing calls on MMModemVoice `%s': %s",
self->name, error->message);
CALLS_ERROR (self, error);
}
return;
}
for (node = calls; node; node = node->next)
{
add_call (self, MM_CALL (node->data));
}
g_list_free_full (calls, g_object_unref);
}
static void
set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
CallsMMOrigin *self = CALLS_MM_ORIGIN (object);
switch (property_id) {
case PROP_MODEM:
g_set_object (&self->mm_obj, g_value_get_object(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gchar *
modem_get_name (MMModem *modem)
{
gchar *name = NULL;
#define try(prop) \
name = mm_modem_dup_##prop (modem); \
if (name) { \
return name; \
}
try (model);
try (manufacturer);
try (device);
try (primary_port);
try (device_identifier);
try (plugin);
#undef try
return NULL;
}
static void
constructed (GObject *object)
{
GObjectClass *parent_class = g_type_class_peek (G_TYPE_OBJECT);
CallsMMOrigin *self = CALLS_MM_ORIGIN (object);
MmGdbusModemVoice *gdbus_voice;
self->name = modem_get_name (mm_object_get_modem (self->mm_obj));
self->voice = mm_object_get_modem_voice (self->mm_obj);
g_assert (self->voice != NULL);
gdbus_voice = MM_GDBUS_MODEM_VOICE (self->voice);
g_signal_connect (gdbus_voice, "call-added",
G_CALLBACK (call_added_cb), self);
g_signal_connect (gdbus_voice, "call-deleted",
G_CALLBACK (call_deleted_cb), self);
mm_modem_voice_list_calls
(self->voice,
NULL,
(GAsyncReadyCallback) list_calls_cb,
self);
parent_class->constructed (object);
}
static void
dispose (GObject *object)
{
GObjectClass *parent_class = g_type_class_peek (G_TYPE_OBJECT);
CallsMMOrigin *self = CALLS_MM_ORIGIN (object);
remove_calls (self, NULL);
g_clear_object (&self->mm_obj);
parent_class->dispose (object);
}
static void
finalize (GObject *object)
{
GObjectClass *parent_class = g_type_class_peek (G_TYPE_OBJECT);
CallsMMOrigin *self = CALLS_MM_ORIGIN (object);
g_hash_table_unref (self->calls);
g_free (self->name);
parent_class->finalize (object);
}
static void
calls_mm_origin_class_init (CallsMMOriginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->set_property = set_property;
object_class->constructed = constructed;
object_class->dispose = dispose;
object_class->finalize = finalize;
props[PROP_MODEM] =
g_param_spec_object ("mm-object",
_("Modem Object"),
_("A libmm-glib proxy object for the modem"),
MM_TYPE_OBJECT,
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties (object_class, PROP_LAST_PROP, props);
}
static void
calls_mm_origin_message_source_interface_init (CallsOriginInterface *iface)
{
}
static void
calls_mm_origin_origin_interface_init (CallsOriginInterface *iface)
{
iface->get_name = get_name;
iface->get_calls = get_calls;
iface->dial = dial;
}
static void
calls_mm_origin_init (CallsMMOrigin *self)
{
self->calls = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_object_unref);
}
CallsMMOrigin *
calls_mm_origin_new (MMObject *mm_obj)
{
return g_object_new (CALLS_TYPE_MM_ORIGIN,
"mm-object", mm_obj,
NULL);
}