/* calls-application.c * * Copyright (C) 2018, 2019 Purism SPC * Copyright (C) 2018 Mohammed Sadiq * * 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 . * * Authors: * Bob Ham * Mohammed Sadiq * * SPDX-License-Identifier: GPL-3.0-or-later */ #include "config.h" #include "calls-history-box.h" #include "calls-new-call-box.h" #include "calls-encryption-indicator.h" #include "calls-ringer.h" #include "calls-record-store.h" #include "calls-call-window.h" #include "calls-main-window.h" #include "calls-application.h" #include "session.h" #define HANDY_USE_UNSTABLE_API #include #include #include #include /** * SECTION: calls-application * @title: CallsApplication * @short_description: Base Application class * @include: "calls-application.h" */ #define DEFAULT_PROVIDER_PLUGIN "mm" struct _CallsApplication { GtkApplication parent_instance; gboolean daemon; GString *provider_name; CallsProvider *provider; CallsRinger *ringer; CallsRecordStore *record_store; CallsMainWindow *main_window; CallsCallWindow *call_window; }; G_DEFINE_TYPE (CallsApplication, calls_application, GTK_TYPE_APPLICATION) static gint handle_local_options (GApplication *application, GVariantDict *options) { gboolean ok; g_autoptr(GError) error = NULL; const gchar *name; g_debug ("Registering application"); ok = g_application_register (application, NULL, &error); if (!ok) { g_error ("Error registering application: %s", error->message); } ok = g_variant_dict_lookup (options, "provider", "&s", &name); if (ok) { g_action_group_activate_action (G_ACTION_GROUP (application), "set-provider-name", g_variant_new_string (name)); } ok = g_variant_dict_contains (options, "daemon"); if (ok) { g_action_group_activate_action (G_ACTION_GROUP (application), "set-daemon", NULL); } return -1; // Continue processing signal } static void set_provider_name_action (GSimpleAction *action, GVariant *parameter, gpointer user_data) { CallsApplication *self = CALLS_APPLICATION (user_data); const gchar *name; name = g_variant_get_string (parameter, NULL); g_return_if_fail (name != NULL); if (self->provider) { g_warning ("Cannot set provider name to `%s'" " because provider is already created", name); return; } g_string_assign (self->provider_name, name); g_debug ("Provider name set to `%s'", self->provider_name->str); } static void set_daemon_action (GSimpleAction *action, GVariant *parameter, gpointer user_data) { CallsApplication *self = CALLS_APPLICATION (user_data); if (self->main_window) { g_warning ("Cannot set application as a daemon" " because application is already started"); return; } self->daemon = TRUE; g_debug ("Application marked as daemon"); } static const GActionEntry actions[] = { { "set-provider-name", set_provider_name_action, "s" }, { "set-daemon", set_daemon_action, NULL }, }; static void startup (GApplication *application) { GtkIconTheme *icon_theme; G_APPLICATION_CLASS (calls_application_parent_class)->startup (application); g_set_prgname (APP_ID); g_set_application_name (_("Calls")); icon_theme = gtk_icon_theme_get_default (); gtk_icon_theme_add_resource_path (icon_theme, "/sm/puri/calls/"); g_action_map_add_action_entries (G_ACTION_MAP (application), actions, G_N_ELEMENTS (actions), application); } static void load_provider_plugin (CallsApplication *self) { const gchar * const name = self->provider_name->str; PeasEngine *plugins; PeasPluginInfo *info; PeasExtension *extension; g_assert (self->provider == NULL); // Add Calls search path and rescan plugins = peas_engine_get_default (); peas_engine_add_search_path (plugins, PLUGIN_LIBDIR, PLUGIN_LIBDIR); g_debug ("Scanning for plugins in `%s'", PLUGIN_LIBDIR); // Find the plugin info = peas_engine_get_plugin_info (plugins, name); if (!info) { g_critical ("Could not find plugin `%s'", name); return; } // Possibly load the plugin if (!peas_plugin_info_is_loaded (info)) { g_autoptr(GError) error = NULL; peas_engine_load_plugin (plugins, info); if (!peas_plugin_info_is_available (info, &error)) { if (error) { g_critical ("Error loading plugin `%s': %s", name, error->message); } else { g_critical ("Could not load plugin `%s'", name); } return; } g_debug ("Loaded plugin `%s'", name); } // Check the plugin provides CallsProvider if (!peas_engine_provides_extension (plugins, info, CALLS_TYPE_PROVIDER)) { g_critical ("Plugin `%s' does not have a provider extension", name); return; } // Get the extension extension = peas_engine_create_extensionv (plugins, info, CALLS_TYPE_PROVIDER, 0, NULL); if (!extension) { g_critical ("Could not create provider from plugin `%s'", name); return; } g_debug ("Created provider from plugin `%s'", name); self->provider = CALLS_PROVIDER (extension); } static gboolean start_proper (CallsApplication *self) { GtkApplication *gtk_app; if (self->main_window) { return TRUE; } gtk_app = GTK_APPLICATION (self); // Later we will make provider loading/unloaded a dynamic // process but that will have far-reaching consequences and is // of no use immediately so for now, we just load one provider // at startup. We can't put this in the actual startup() method // though, because we need to be able to set the provider name // from the command line and we use actions to do that, which // depend on the application already being started up. load_provider_plugin (self); if (!self->provider) { g_application_quit (G_APPLICATION (self)); return FALSE; } self->ringer = calls_ringer_new (self->provider); g_assert (self->ringer != NULL); self->record_store = calls_record_store_new (self->provider); g_assert (self->record_store != NULL); self->main_window = calls_main_window_new (gtk_app, self->provider, G_LIST_MODEL (self->record_store)); g_assert (self->main_window != NULL); self->call_window = calls_call_window_new (gtk_app, self->provider); g_assert (self->call_window != NULL); return TRUE; } static void activate (GApplication *application) { CallsApplication *self = CALLS_APPLICATION (application); gboolean present; g_debug ("Activated"); if (self->main_window) { present = TRUE; } else { gboolean ok = start_proper (self); if (!ok) { return; } present = !self->daemon; } if (present) { gtk_window_present (GTK_WINDOW (self->main_window)); } } static void open_tel_uri (CallsApplication *self, const gchar *uri) { EPhoneNumber *number; GError *error = NULL; gchar *dial_str; g_debug ("Opening tel URI `%s'", uri); number = e_phone_number_from_string (uri, NULL, &error); if (!number) { g_warning ("Ignoring unparsable tel URI `%s': %s", uri, error->message); g_error_free (error); return; } dial_str = e_phone_number_to_string (number, E_PHONE_NUMBER_FORMAT_E164); e_phone_number_free (number); calls_main_window_dial (self->main_window, dial_str); g_free (dial_str); } static void app_open (GApplication *application, GFile **files, gint n_files, const gchar *hint) { CallsApplication *self = CALLS_APPLICATION (application); gint i; g_assert (n_files > 0); g_debug ("Opened (%i files)", n_files); start_proper (self); for (i = 0; i < n_files; ++i) { gchar *uri; if (g_file_has_uri_scheme (files[i], "tel")) { uri = g_file_get_uri (files[i]); open_tel_uri (self, uri); } else { uri = g_file_get_parse_name (files[i]); g_warning ("Don't know how to" " open file `%s', ignoring", uri); } g_free (uri); } } static void constructed (GObject *object) { GObjectClass *parent_class = g_type_class_peek (GTK_TYPE_APPLICATION); CallsApplication *self = CALLS_APPLICATION (object); GSimpleActionGroup *action_group; action_group = g_simple_action_group_new (); g_action_map_add_action_entries (G_ACTION_MAP (action_group), actions, G_N_ELEMENTS (actions), self); g_object_unref (action_group); calls_session_register (APP_ID); parent_class->constructed (object); } static void dispose (GObject *object) { CallsApplication *self = (CallsApplication *)object; calls_session_unregister (); g_clear_object (&self->call_window); g_clear_object (&self->main_window); g_clear_object (&self->record_store); g_clear_object (&self->ringer); g_clear_object (&self->provider); G_OBJECT_CLASS (calls_application_parent_class)->dispose (object); } static void finalize (GObject *object) { CallsApplication *self = (CallsApplication *)object; g_string_free (self->provider_name, TRUE); G_OBJECT_CLASS (calls_application_parent_class)->finalize (object); } static void calls_application_class_init (CallsApplicationClass *klass) { GApplicationClass *application_class = G_APPLICATION_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->constructed = constructed; object_class->dispose = dispose; object_class->finalize = finalize; application_class->handle_local_options = handle_local_options; application_class->startup = startup; application_class->activate = activate; application_class->open = app_open; g_type_ensure (CALLS_TYPE_ENCRYPTION_INDICATOR); g_type_ensure (CALLS_TYPE_HISTORY_BOX); g_type_ensure (CALLS_TYPE_NEW_CALL_BOX); g_type_ensure (HDY_TYPE_DIALER); g_type_ensure (HDY_TYPE_HEADER_BAR); g_type_ensure (HDY_TYPE_SQUEEZER); g_type_ensure (HDY_TYPE_VIEW_SWITCHER); g_type_ensure (HDY_TYPE_VIEW_SWITCHER_BAR); } static void calls_application_init (CallsApplication *self) { const GOptionEntry options[] = { { "provider", 'p', G_OPTION_FLAG_NONE, G_OPTION_ARG_STRING, NULL, _("The name of the plugin to use for the call Provider"), _("PLUGIN") }, { "daemon", 'd', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL, _("Whether to present the main window on startup"), NULL }, { NULL } }; g_application_add_main_option_entries (G_APPLICATION (self), options); self->provider_name = g_string_new (DEFAULT_PROVIDER_PLUGIN); } CallsApplication * calls_application_new (void) { return g_object_new (CALLS_TYPE_APPLICATION, "application-id", APP_ID, "flags", G_APPLICATION_HANDLES_OPEN, NULL); }