depau/Purism-Calls
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/calls.git synced 2024-11-16 05:15:36 +00:00
Code Issues Releases Wiki Activity
Purism-Calls/src/calls-manager.c

1089 lines
30 KiB
C
Raw Normal View History

Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
/*
* Copyright (C) 2020 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: Julian Sparber <julian.sparber@puri.sm>
Remove CallsCredentials and adapt to changes The provider knows best which credentials it needs and CallsCredentials was not generic to begin with, so get rid of it.
2021-07-03 22:20:57 +00:00
* Evangelos Ribeiro Tzaras <evangelos.tzaras@puri.sm>
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
debug: Add G_LOG_DOMAIN to every file using g_debug()
2021-06-18 09:10:36 +00:00
#define G_LOG_DOMAIN "CallsManager"
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
#include "config.h"
tests: manager: Add multiple provider tests The test suite can be further expanded later. For now this suffices to have some basic regression testing for multiple provider support in place.
2021-05-05 18:53:37 +00:00
manager: Propagate messages from account Not all portions from the user interface are listening directly to messages from accounts, so the manager should propagate them to allow the UI to pick them up. Closes #340
2021-12-28 14:32:22 +00:00
#include "calls-account.h"
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
#include "calls-contacts-provider.h"
tests: manager: Add multiple provider tests The test suite can be further expanded later. For now this suffices to have some basic regression testing for multiple provider support in place.
2021-05-05 18:53:37 +00:00
#include "calls-manager.h"
manager: Implement message source interface This allows the user interface to pick up messages by having them propagate from the managed providers, origins, calls, etc.
2021-12-28 13:43:54 +00:00
#include "calls-message-source.h"
tests: manager: Add multiple provider tests The test suite can be further expanded later. For now this suffices to have some basic regression testing for multiple provider support in place.
2021-05-05 18:53:37 +00:00
#include "calls-provider.h"
Simplify country code handling
2021-09-23 07:32:37 +00:00
#include "calls-settings.h"
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
#include "calls-ui-call-data.h"
tests: manager: Add multiple provider tests The test suite can be further expanded later. For now this suffices to have some basic regression testing for multiple provider support in place.
2021-05-05 18:53:37 +00:00
#include "calls-ussd.h"
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
#include "enum-types.h"
#include <glib/gi18n.h>
#include <libpeas/peas.h>
manager: Add section documentation
2022-02-06 08:56:31 +00:00
/**
* SECTION:manager
* @short_description: Central management object
* @Title: CallsManager
*
* #CallsManager is a singleton that manages lists of loaded #CallsProvider,
* #CallsOrigin and #CallsCall objects. It keeps track of which #CallsOrigin
* supports which protocol. It also checks which #CallsCall are ongoing and
* emits signals for the UI and other parts of the application to act on.
*/
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
static const char * const protocols[] = {
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
"tel",
"sip",
"sips"
};
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
struct _CallsManager {
GObject parent_instance;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
GHashTable *providers;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
GListStore *origins;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
/* origins_by_protocol maps protocol names to GListStore's of suitable origins */
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
GHashTable *origins_by_protocol;
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
/* dial_actions_by_protocol maps protocol names to GSimpleActions */
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
GHashTable *dial_actions_by_protocol;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
/* map CallsCall to CallsUiCallData */
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
GHashTable *calls;
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
CallsContactsProvider *contacts_provider;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
CallsManagerFlags state_flags;
CallsSettings *settings;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
};
manager: Implement message source interface This allows the user interface to pick up messages by having them propagate from the managed providers, origins, calls, etc.
2021-12-28 13:43:54 +00:00
static void
calls_manager_message_source_interface_init (CallsMessageSourceInterface *iface)
{
}
G_DEFINE_TYPE_WITH_CODE (CallsManager, calls_manager, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (CALLS_TYPE_MESSAGE_SOURCE,
calls_manager_message_source_interface_init))
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
enum {
PROP_0,
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
PROP_STATE_FLAGS,
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
PROP_LAST_PROP,
};
static GParamSpec *props[PROP_LAST_PROP];
enum {
manager: Remove call-add and call-remove signal They are phased out in favour of their newly introduced ui-call-* pendants. This was done to have a better separation of concerns and allows for some cleanup in CallsCall. Closes #397
2022-02-04 03:46:00 +00:00
UI_CALL_ADDDED,
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
UI_CALL_REMOVED,
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
USSD_ADDED,
USSD_CANCELLED,
USSD_STATE_CHANGED,
manager: Emit signal when loaded providers have changed
2021-07-03 23:42:04 +00:00
PROVIDERS_CHANGED,
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
SIGNAL_LAST_SIGNAL,
};
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
static guint signals[SIGNAL_LAST_SIGNAL];
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
set_state_flags (CallsManager *self, CallsManagerFlags state_flags)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
if (self->state_flags == state_flags)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
return;
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
self->state_flags = state_flags;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
g_object_notify_by_pspec (G_OBJECT (self), props[PROP_STATE_FLAGS]);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
static void
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
update_state_flags (CallsManager *self)
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
{
manager: Differentiate the NO_ORIGIN state This avoids confusion when only the SIP plugin is loaded, but no account is being used. For this we introduce two new functions in the abstract CallsProvider class: `is_modem()` to indicate whether the the provider deals with PTSN telephony and `is_operational()` which by default simply checks if there any avalaible origins
2021-05-04 19:49:07 +00:00
GHashTableIter iter;
gpointer value;
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
CallsManagerFlags state_flags = CALLS_MANAGER_FLAGS_UNKNOWN;
manager: Differentiate the NO_ORIGIN state This avoids confusion when only the SIP plugin is loaded, but no account is being used. For this we introduce two new functions in the abstract CallsProvider class: `is_modem()` to indicate whether the the provider deals with PTSN telephony and `is_operational()` which by default simply checks if there any avalaible origins
2021-05-04 19:49:07 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_assert (CALLS_IS_MANAGER (self));
manager: Differentiate the NO_ORIGIN state This avoids confusion when only the SIP plugin is loaded, but no account is being used. For this we introduce two new functions in the abstract CallsProvider class: `is_modem()` to indicate whether the the provider deals with PTSN telephony and `is_operational()` which by default simply checks if there any avalaible origins
2021-05-04 19:49:07 +00:00
g_hash_table_iter_init (&iter, self->providers);
manager: Remove unused key argument in g_hash_table_iter_next() We're only interested in the value here.
2022-01-26 07:32:35 +00:00
while (g_hash_table_iter_next (&iter, NULL, &value)) {
manager: Differentiate the NO_ORIGIN state This avoids confusion when only the SIP plugin is loaded, but no account is being used. For this we introduce two new functions in the abstract CallsProvider class: `is_modem()` to indicate whether the the provider deals with PTSN telephony and `is_operational()` which by default simply checks if there any avalaible origins
2021-05-04 19:49:07 +00:00
CallsProvider *provider = CALLS_PROVIDER (value);
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
if (calls_provider_is_modem (provider)) {
state_flags |= CALLS_MANAGER_FLAGS_HAS_CELLULAR_PROVIDER;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
if (calls_provider_is_operational (provider))
state_flags |= CALLS_MANAGER_FLAGS_HAS_CELLULAR_MODEM;
} else {
state_flags |= CALLS_MANAGER_FLAGS_HAS_VOIP_PROVIDER;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
if (calls_provider_is_operational (provider))
state_flags |= CALLS_MANAGER_FLAGS_HAS_VOIP_ACCOUNT;
}
}
set_state_flags (self, state_flags);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
static void
on_dial_protocol_activated (GSimpleAction *action,
GVariant *parameter,
CallsManager *self)
{
GApplication *application;
CallsOrigin *origin;
g_autofree char *target = NULL;
g_autofree char *origin_id = NULL;
g_variant_get (parameter, "(ss)", &target, &origin_id);
ui-call-data: Provide API to get the name of the origin used This will be used as a fallback when displaying the call details (see #222).
2022-02-10 09:12:16 +00:00
origin = calls_manager_get_origin_by_id (self, origin_id);
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
if (origin) {
calls_origin_dial (origin, target);
return;
}
if (origin_id && *origin_id)
g_debug ("Origin ID '%s' given, but was not found for call to '%s'",
origin_id, target);
/* fall back to the default action if we could not determine origin to place call from */
application = g_application_get_default ();
if (!application) {
g_warning ("Could not get default application, cannot activate action '%s'",
g_action_get_name (G_ACTION (action)));
return;
}
g_action_group_activate_action (G_ACTION_GROUP (application),
"dial",
g_variant_new_string (target));
}
static void
update_protocol_dial_actions (CallsManager *self)
{
g_assert (CALLS_IS_MANAGER (self));
for (guint i = 0; i < G_N_ELEMENTS (protocols); i++) {
GSimpleAction *action = g_hash_table_lookup (self->dial_actions_by_protocol,
protocols[i]);
GListModel *protocol_origin = g_hash_table_lookup (self->origins_by_protocol,
protocols[i]);
/* TODO take into account if origin is active: modem registered or VoIP account online */
gboolean action_enabled = g_list_model_get_n_items (protocol_origin) > 0;
g_simple_action_set_enabled (action, action_enabled);
}
}
manager: Propagate messages from account Not all portions from the user interface are listening directly to messages from accounts, so the manager should propagate them to allow the UI to pick them up. Closes #340
2021-12-28 14:32:22 +00:00
static void
on_message (CallsMessageSource *source,
const char *message,
GtkMessageType message_type,
CallsManager *self)
{
g_autofree char *notification = NULL;
g_assert (CALLS_IS_MESSAGE_SOURCE (source));
g_assert (CALLS_IS_MANAGER (self));
/* Prefix the message with the name of the source, if known */
if (CALLS_IS_ACCOUNT (source)) {
notification = g_strdup_printf ("%s: %s",
calls_account_get_address (CALLS_ACCOUNT (source)),
message);
}
manager: Use ternary operator instead of if/else block Less code is better code.
2022-01-13 15:03:38 +00:00
calls_message_source_emit_message (CALLS_MESSAGE_SOURCE (self),
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
notification ?: message,
manager: Use ternary operator instead of if/else block Less code is better code.
2022-01-13 15:03:38 +00:00
message_type);
manager: Propagate messages from account Not all portions from the user interface are listening directly to messages from accounts, so the manager should propagate them to allow the UI to pick them up. Closes #340
2021-12-28 14:32:22 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
add_call (CallsManager *self, CallsCall *call, CallsOrigin *origin)
{
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
CallsUiCallData *call_data;
ui-call-data: Store origin id and adapt to changes
2022-02-03 17:52:52 +00:00
g_autofree char *origin_id = NULL;
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
g_return_if_fail (CALLS_IS_MANAGER (self));
g_return_if_fail (CALLS_IS_ORIGIN (origin));
g_return_if_fail (CALLS_IS_CALL (call));
ui-call-data: Store origin id and adapt to changes
2022-02-03 17:52:52 +00:00
origin_id = calls_origin_get_id (origin);
call_data = calls_ui_call_data_new (call, origin_id);
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
g_hash_table_insert (self->calls, call, call_data);
g_signal_emit (self, signals[UI_CALL_ADDDED], 0, call_data);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
struct CallsRemoveData {
manager: Delay UI Call removal and adjust to changes This was handled explicitly in the Call window. By changing the logic to delay the emission of "ui-call-removed" we make sure that the Call UI and the exported DBus object is consistent. We also need to change the test cases to use run a GMainLoop because we now have to wait until signal comes in.
2022-02-03 06:49:55 +00:00
CallsManager *manager;
CallsCall *call;
};
static gboolean
on_remove_delayed (struct CallsRemoveData *data)
{
CallsUiCallData *call_data;
g_assert (CALLS_IS_MANAGER (data->manager));
g_assert (CALLS_IS_CALL (data->call));
call_data = g_hash_table_lookup (data->manager->calls, data->call);
if (!call_data) {
g_warning ("Could not find call %s in UI call hash table",
calls_call_get_id (data->call));
} else {
g_signal_emit (data->manager, signals[UI_CALL_REMOVED], 0, call_data);
g_hash_table_remove (data->manager->calls, data->call);
}
g_free (data);
return G_SOURCE_REMOVE;
}
#define DELAY_CALL_REMOVE_MS 3000
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
remove_call (CallsManager *self, CallsCall *call, gchar *reason, CallsOrigin *origin)
{
manager: Delay UI Call removal and adjust to changes This was handled explicitly in the Call window. By changing the logic to delay the emission of "ui-call-removed" we make sure that the Call UI and the exported DBus object is consistent. We also need to change the test cases to use run a GMainLoop because we now have to wait until signal comes in.
2022-02-03 06:49:55 +00:00
struct CallsRemoveData *data;
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
g_return_if_fail (CALLS_IS_MANAGER (self));
g_return_if_fail (CALLS_IS_ORIGIN (origin));
g_return_if_fail (CALLS_IS_CALL (call));
manager: Delay UI Call removal and adjust to changes This was handled explicitly in the Call window. By changing the logic to delay the emission of "ui-call-removed" we make sure that the Call UI and the exported DBus object is consistent. We also need to change the test cases to use run a GMainLoop because we now have to wait until signal comes in.
2022-02-03 06:49:55 +00:00
data = g_new (struct CallsRemoveData, 1);
data->manager = self;
data->call = call;
/** Having the delay centrally managed makes sure our UI
* and the DBus side stays consistent
*/
g_timeout_add (DELAY_CALL_REMOVE_MS,
G_SOURCE_FUNC (on_remove_delayed),
data);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Delay UI Call removal and adjust to changes This was handled explicitly in the Call window. By changing the logic to delay the emission of "ui-call-removed" we make sure that the Call UI and the exported DBus object is consistent. We also need to change the test cases to use run a GMainLoop because we now have to wait until signal comes in.
2022-02-03 06:49:55 +00:00
#undef DELAY_CALL_REMOVE_MS
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
static void
ussd_added_cb (CallsManager *self,
char *response,
CallsUssd *ussd)
{
g_assert (CALLS_IS_MANAGER (self));
g_assert (CALLS_IS_USSD (ussd));
g_signal_emit (self, signals[USSD_ADDED], 0, ussd, response);
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
static void
ussd_cancelled_cb (CallsManager *self,
CallsUssd *ussd,
char *response)
{
g_assert (CALLS_IS_MANAGER (self));
g_assert (CALLS_IS_USSD (ussd));
g_signal_emit (self, signals[USSD_CANCELLED], 0, ussd);
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
static void
ussd_state_changed_cb (CallsManager *self,
CallsUssd *ussd)
{
g_assert (CALLS_IS_MANAGER (self));
g_assert (CALLS_IS_USSD (ussd));
g_signal_emit (self, signals[USSD_STATE_CHANGED], 0, ussd);
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Update country code By connecting to the "notify::country-code" signal of our origins.
2021-05-18 16:31:05 +00:00
static void
update_country_code_cb (CallsOrigin *origin,
GParamSpec *pspec,
CallsManager *self)
{
g_autofree char *country_code = NULL;
g_assert (CALLS_IS_MANAGER (self));
g_object_get (G_OBJECT (origin), "country-code", &country_code, NULL);
Simplify country code handling
2021-09-23 07:32:37 +00:00
if (!country_code || !*country_code)
manager: Update country code By connecting to the "notify::country-code" signal of our origins.
2021-05-18 16:31:05 +00:00
return;
Simplify country code handling
2021-09-23 07:32:37 +00:00
calls_settings_set_country_code (self->settings, country_code);
manager: Update country code By connecting to the "notify::country-code" signal of our origins.
2021-05-18 16:31:05 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
manager: remove unused CallsProvider argument from functions Both add_origin() and remove_origin() don't really need it.
2021-04-18 00:33:13 +00:00
add_origin (CallsManager *self, CallsOrigin *origin)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
cleanup: Fix calls_origin_get_name() related memory leaks Document calls_origin_get_name() correctly as transfer-full. Additionaly fix related memory leaks.
2021-05-13 15:35:10 +00:00
g_autofree const char *name = NULL;
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
manager: g_assert in static functions
2021-04-14 14:05:40 +00:00
g_assert (CALLS_IS_MANAGER (self));
g_assert (CALLS_IS_ORIGIN (origin));
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
cleanup: Fix calls_origin_get_name() related memory leaks Document calls_origin_get_name() correctly as transfer-full. Additionaly fix related memory leaks.
2021-05-13 15:35:10 +00:00
name = calls_origin_get_name (origin);
g_debug ("Adding origin %s (%p)", name, origin);
manager: add debug messages when adding or removing origins
2021-04-17 14:43:21 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_list_store_append (self->origins, origin);
manager: Propagate messages from account Not all portions from the user interface are listening directly to messages from accounts, so the manager should propagate them to allow the UI to pick them up. Closes #340
2021-12-28 14:32:22 +00:00
g_signal_connect (origin,
"message",
G_CALLBACK (on_message),
self);
manager: Update country code By connecting to the "notify::country-code" signal of our origins.
2021-05-18 16:31:05 +00:00
g_signal_connect_object (origin,
"notify::country-code",
G_CALLBACK (update_country_code_cb),
self,
G_CONNECT_AFTER);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
g_signal_connect_swapped (origin, "call-added", G_CALLBACK (add_call), self);
g_signal_connect_swapped (origin, "call-removed", G_CALLBACK (remove_call), self);
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
if (CALLS_IS_USSD (origin)) {
g_signal_connect_swapped (origin, "ussd-added", G_CALLBACK (ussd_added_cb), self);
g_signal_connect_swapped (origin, "ussd-cancelled", G_CALLBACK (ussd_cancelled_cb), self);
g_signal_connect_swapped (origin, "ussd-state-changed", G_CALLBACK (ussd_state_changed_cb), self);
}
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
calls_origin_foreach_call (origin, (CallsOriginForeachCallFunc) add_call, self);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Replace CallsOrigin getters with properties and add calls_origin_foreach_call method
2020-03-23 22:10:05 +00:00
static void
remove_call_cb (gpointer self, CallsCall *call, CallsOrigin *origin)
{
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
remove_call (self, call, NULL, origin);
Replace CallsOrigin getters with properties and add calls_origin_foreach_call method
2020-03-23 22:10:05 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
manager: remove unused CallsProvider argument from functions Both add_origin() and remove_origin() don't really need it.
2021-04-18 00:33:13 +00:00
remove_origin (CallsManager *self, CallsOrigin *origin)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
cleanup: Fix calls_origin_get_name() related memory leaks Document calls_origin_get_name() correctly as transfer-full. Additionaly fix related memory leaks.
2021-05-13 15:35:10 +00:00
g_autofree const char *name = NULL;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
guint position;
Replace CallsOrigin getters with properties and add calls_origin_foreach_call method
2020-03-23 22:10:05 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_assert (CALLS_IS_MANAGER (self));
g_assert (CALLS_IS_ORIGIN (origin));
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
cleanup: Fix calls_origin_get_name() related memory leaks Document calls_origin_get_name() correctly as transfer-full. Additionaly fix related memory leaks.
2021-05-13 15:35:10 +00:00
name = calls_origin_get_name (origin);
g_debug ("Removing origin %s (%p)", name, origin);
manager: add debug messages when adding or removing origins
2021-04-17 14:43:21 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
g_signal_handlers_disconnect_by_data (origin, self);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
calls_origin_foreach_call (origin, remove_call_cb, self);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
if (!g_list_store_find (self->origins, origin, &position))
g_warning ("Origin %p not found in list store while trying to remove it",
origin);
else
g_list_store_remove (self->origins, position);
}
/* rebuild_origins_by_protocols() when any origins were added or removed */
static void
rebuild_origins_by_protocols (CallsManager *self)
{
GHashTableIter iter;
manager: Remove unused key argument in g_hash_table_iter_next() We're only interested in the value here.
2022-01-26 07:32:35 +00:00
gpointer value;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
guint n_origins;
g_assert (CALLS_IS_MANAGER (self));
/* Remove everything */
g_hash_table_iter_init (&iter, self->origins_by_protocol);
manager: Remove unused key argument in g_hash_table_iter_next() We're only interested in the value here.
2022-01-26 07:32:35 +00:00
while (g_hash_table_iter_next (&iter, NULL, &value)) {
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
GListStore *store = G_LIST_STORE (value);
g_list_store_remove_all (store);
}
/* Iterate over all origins and check which protocols they support */
n_origins = g_list_model_get_n_items (G_LIST_MODEL (self->origins));
for (guint i = 0; i < n_origins; i++) {
g_autoptr (CallsOrigin) origin =
g_list_model_get_item (G_LIST_MODEL (self->origins), i);
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
for (guint j = 0; j < G_N_ELEMENTS (protocols); j++) {
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
GListStore *store =
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
G_LIST_STORE (g_hash_table_lookup (self->origins_by_protocol, protocols[j]));
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_assert (store);
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
if (calls_origin_supports_protocol (origin, protocols[j]))
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_list_store_append (store, origin);
}
}
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
update_protocol_dial_actions (self);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
remove_provider (CallsManager *self,
const char *name)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
g_autoptr (CallsProvider) provider = NULL;
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
GListModel *origins;
guint n_items;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_assert (CALLS_IS_MANAGER (self));
g_assert (name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
provider = g_hash_table_lookup (self->providers, name);
manager: Temporarily hold a reference to provider being unloaded
2021-07-07 14:12:23 +00:00
if (provider) {
/* Hold a ref since g_hash_table_remove () might drop the last one */
g_object_ref (provider);
} else {
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_warning ("Trying to remove provider %s which has not been found", name);
return;
}
g_debug ("Remove provider: %s", name);
g_signal_handlers_disconnect_by_data (provider, self);
origins = calls_provider_get_origins (provider);
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
g_signal_handlers_disconnect_by_data (origins, self);
n_items = g_list_model_get_n_items (origins);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: codestyle
2021-06-09 02:03:31 +00:00
for (guint i = 0; i < n_items; i++) {
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
g_autoptr (CallsOrigin) origin = NULL;
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
manager: codestyle
2021-06-09 02:03:31 +00:00
origin = g_list_model_get_item (origins, i);
remove_origin (self, origin);
}
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_hash_table_remove (self->providers, name);
calls_provider_unload_plugin (name);
rebuild_origins_by_protocols (self);
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
update_state_flags (self);
manager: Emit signal when loaded providers have changed
2021-07-03 23:42:04 +00:00
g_signal_emit (self, signals[PROVIDERS_CHANGED], 0);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
static gboolean
origin_found_in_any_provider (CallsManager *self,
CallsOrigin *origin)
{
GHashTableIter iter;
manager: Remove unused key argument in g_hash_table_iter_next() We're only interested in the value here.
2022-01-26 07:32:35 +00:00
gpointer value;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_return_val_if_fail (CALLS_IS_MANAGER (self), FALSE);
g_return_val_if_fail (CALLS_IS_ORIGIN (origin), FALSE);
g_hash_table_iter_init (&iter, self->providers);
manager: Remove unused key argument in g_hash_table_iter_next() We're only interested in the value here.
2022-01-26 07:32:35 +00:00
while (g_hash_table_iter_next (&iter, NULL, &value)) {
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
guint position;
CallsProvider *provider = CALLS_PROVIDER (value);
GListModel *origins = calls_provider_get_origins (provider);
util: Rename function to calls_find_in_model() and adjust documentation Since it works for GListModel rename it appropriately. It used to provide an inline implementation for g_list_store_find() behind a glib version guard, but we bumped minimum version in cfd3c2a7fe418b678bfaffa58e87238128a11008 so the docstring was updated and made more succinct.
2022-10-10 06:39:42 +00:00
if (origins && calls_find_in_model (origins,
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
origin,
&position))
return TRUE;
}
provider: Add API for loading and unloading provider plugins This is also used for our tests. In order to avoid code duplication this is being moved to calls-provider.{c,h}.
2021-04-02 14:04:07 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
return FALSE;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
static void
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
origin_items_changed_cb (GListModel *model,
guint position,
guint removed,
guint added,
CallsManager *self)
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
{
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
guint i;
CallsOrigin *origin;
guint purged = 0;
guint total_origins;
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
g_assert (CALLS_IS_MANAGER (self));
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
total_origins = g_list_model_get_n_items (G_LIST_MODEL (self->origins));
g_debug ("origins changed: pos=%d rem=%d added=%d total=%d",
position, removed, added, g_list_model_get_n_items (model));
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
/* Check stale/removed origins: We need to look up */
if (removed == 0)
goto skip_remove;
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
for (i = 0; i < total_origins - purged; i++) {
origin = g_list_model_get_item (G_LIST_MODEL (self->origins), i - purged);
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
if (!origin_found_in_any_provider (self, origin)) {
remove_origin (self, origin);
purged++;
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
}
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
}
/** The number of purged entries from self->origins must be equal to removed
* origins from the providers list
*/
if (purged != removed) {
g_warning ("Managed origins are not in sync anymore!");
}
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
skip_remove:
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
for (i = 0; i < added; i++) {
g_debug ("before adding: %d",
g_list_model_get_n_items (G_LIST_MODEL (self->origins)));
origin = g_list_model_get_item (model, position + i);
add_origin (self, origin); // add to list store
g_object_unref (origin);
g_debug ("after adding: %d",
g_list_model_get_n_items (G_LIST_MODEL (self->origins)));
}
rebuild_origins_by_protocols (self);
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
update_state_flags (self);
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
add_provider (CallsManager *self, const gchar *name)
{
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
GListModel *origins;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
CallsProvider *provider;
guint n_items;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_assert (CALLS_IS_MANAGER (self));
g_assert (name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
if (g_hash_table_lookup (self->providers, name))
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
return;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
provider = calls_provider_load_plugin (name);
if (provider == NULL) {
g_warning ("Could not load a plugin with name `%s'", name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
return;
}
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_hash_table_insert (self->providers, g_strdup (name), provider);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
origins = calls_provider_get_origins (provider);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
g_signal_connect_object (origins, "items-changed",
G_CALLBACK (origin_items_changed_cb), self,
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
G_CONNECT_AFTER);
n_items = g_list_model_get_n_items (origins);
origin_items_changed_cb (origins, 0, 0, n_items, self);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Emit signal when loaded providers have changed
2021-07-03 23:42:04 +00:00
g_signal_emit (self, signals[PROVIDERS_CHANGED], 0);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
calls_manager_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
CallsManager *self = CALLS_MANAGER (object);
switch (property_id) {
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
case PROP_STATE_FLAGS:
g_value_set_flags (value, calls_manager_get_state_flags (self));
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
break;
manager: remove trailing whitespace
2021-01-11 23:00:20 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
manager: remove trailing whitespace
2021-01-11 23:00:20 +00:00
}
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
static void
calls_manager_finalize (GObject *object)
{
CallsManager *self = CALLS_MANAGER (object);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_clear_object (&self->origins);
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
g_clear_object (&self->contacts_provider);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_clear_pointer (&self->providers, g_hash_table_unref);
g_clear_pointer (&self->origins_by_protocol, g_hash_table_unref);
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
g_clear_pointer (&self->dial_actions_by_protocol, g_hash_table_unref);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
G_OBJECT_CLASS (calls_manager_parent_class)->finalize (object);
}
static void
calls_manager_class_init (CallsManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->get_property = calls_manager_get_property;
object_class->finalize = calls_manager_finalize;
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
signals[UI_CALL_ADDDED] =
g_signal_new ("ui-call-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1,
CALLS_TYPE_UI_CALL_DATA);
signals[UI_CALL_REMOVED] =
g_signal_new ("ui-call-removed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1,
CALLS_TYPE_UI_CALL_DATA);
manager: Hook to ussd signals from provider
2020-07-07 12:40:31 +00:00
signals[USSD_ADDED] =
g_signal_new ("ussd-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
2,
CALLS_TYPE_USSD,
G_TYPE_STRING);
signals[USSD_CANCELLED] =
g_signal_new ("ussd-cancelled",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1,
CALLS_TYPE_USSD);
signals[USSD_STATE_CHANGED] =
g_signal_new ("ussd-state-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1,
CALLS_TYPE_USSD);
manager: Emit signal when loaded providers have changed
2021-07-03 23:42:04 +00:00
signals[PROVIDERS_CHANGED] =
g_signal_new ("providers-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
0);
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
props[PROP_STATE_FLAGS] =
g_param_spec_flags ("state",
"state",
"The state of the Manager",
CALLS_TYPE_MANAGER_FLAGS,
CALLS_MANAGER_FLAGS_UNKNOWN,
G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
g_object_class_install_properties (object_class, PROP_LAST_PROP, props);
}
static void
calls_manager_init (CallsManager *self)
{
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
g_autoptr (GVariantType) variant_type = NULL;
GApplication *application;
manager: Set peas search path only once There is no need to redo it for every added plugin.
2021-04-21 09:31:29 +00:00
PeasEngine *peas;
const gchar *dir;
Move plugin specific tests into dedicated directory This will prove beneficial when we also add tests for the policy engine plugins. The increased locality is also nice to have.
2022-07-18 20:30:19 +00:00
g_autofree char *default_plugin_dir_provider = NULL;
manager: Set peas search path only once There is no need to redo it for every added plugin.
2021-04-21 09:31:29 +00:00
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
self->state_flags = CALLS_MANAGER_FLAGS_UNKNOWN;
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
self->providers = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
self->origins_by_protocol = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
for (guint i = 0; i < G_N_ELEMENTS (protocols); i++) {
GListStore *origin_store = g_list_store_new (calls_origin_get_type ());
g_hash_table_insert (self->origins_by_protocol,
g_strdup (protocols[i]),
origin_store);
}
manager: Add per protocol dial actions These are enabled or disabled based on availability of suitable origins. Allows CallsCallRecordRows (GtkListBoxRows in the call history) to use protocol specific instead of global dial action. Closes #307
2022-01-26 06:53:58 +00:00
self->dial_actions_by_protocol = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
application = g_application_get_default ();
variant_type = g_variant_type_new ("(ss)");
for (guint i = 0; i < G_N_ELEMENTS (protocols); i++) {
g_autofree char *action_name = g_strdup_printf ("dial-%s", protocols[i]);
GSimpleAction *action = g_simple_action_new (action_name, variant_type);
g_signal_connect (action,
"activate",
G_CALLBACK (on_dial_protocol_activated),
self);
g_hash_table_insert (self->dial_actions_by_protocol,
g_strdup (protocols[i]),
g_object_ref (action));
/* Enable action if there are suitable origins */
g_simple_action_set_enabled (action, FALSE);
/* application can be NULL when running tests */
if (application)
g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
}
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
self->origins = g_list_store_new (calls_origin_get_type ());
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
manager: Add new set of add and remove signals for CuiCalls This is part of a refactoring which should help separating concerns between CallsCall and CallsUiCallData better. To accomplish this we want to stop passing around CallsCall objects and instead pass CallsUiCallData objects. In this commit we added new signals instead of changing the existing ones because that results in a lot of churn. It allows to do the switch per module allowing smaller individual patches and a more manageable patchset.
2022-01-13 14:55:03 +00:00
/* This hash table only owns the value, not the key */
self->calls = g_hash_table_new_full (NULL, NULL, NULL, g_object_unref);
settings: Convert to the singleton pattern We only have a single source of settings, so we should reflect that by using a singleton. This also reduces our LoC. This doesn't impair our ability to run tests because there we run with GSETTINGS_BACKEND=memory
2022-05-09 20:57:41 +00:00
self->settings = calls_settings_get_default ();
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
// Load the contacts provider
settings: Convert to the singleton pattern We only have a single source of settings, so we should reflect that by using a singleton. This also reduces our LoC. This doesn't impair our ability to run tests because there we run with GSETTINGS_BACKEND=memory
2022-05-09 20:57:41 +00:00
self->contacts_provider = calls_contacts_provider_new ();
manager: Set peas search path only once There is no need to redo it for every added plugin.
2021-04-21 09:31:29 +00:00
peas = peas_engine_get_default ();
dir = g_getenv ("CALLS_PLUGIN_DIR");
if (dir && dir[0] != '\0') {
Move plugin specific tests into dedicated directory This will prove beneficial when we also add tests for the policy engine plugins. The increased locality is also nice to have.
2022-07-18 20:30:19 +00:00
g_autofree char *plugin_dir_provider = NULL;
plugin_dir_provider = g_build_filename (dir, "provider", NULL);
manager: Only set search path from CALLS_PLUGIN_DIR when path exists Libpeas has issues searching in a path that doesn't exsist.
2022-09-22 15:54:44 +00:00
if (g_file_test (plugin_dir_provider, G_FILE_TEST_EXISTS)) {
g_debug ("Adding %s to plugin search path", plugin_dir_provider);
peas_engine_prepend_search_path (peas, plugin_dir_provider, NULL);
} else {
g_warning ("Not adding %s to plugin search path, because the directory doesn't exist. Check if env CALLS_PLUGIN_DIR is set correctly", plugin_dir_provider);
}
manager: Set peas search path only once There is no need to redo it for every added plugin.
2021-04-21 09:31:29 +00:00
}
Move plugin specific tests into dedicated directory This will prove beneficial when we also add tests for the policy engine plugins. The increased locality is also nice to have.
2022-07-18 20:30:19 +00:00
default_plugin_dir_provider = g_build_filename(PLUGIN_LIBDIR, "provider", NULL);
peas_engine_add_search_path (peas, default_plugin_dir_provider, NULL);
g_debug ("Scanning for plugins in `%s'", default_plugin_dir_provider);
plugins: Rescan for plugins after adding search paths Using rescan allows use to give a priority to search paths. So this way plugins in `CALLS_PLUGIN_DIR` take precedence over plugins we ship. This also makes sure that the plugin test searches in the same location as CallsManager.
2022-10-26 13:09:11 +00:00
peas_engine_rescan_plugins (peas);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
CallsManager *
calls_manager_new (void)
{
return g_object_new (CALLS_TYPE_MANAGER, NULL);
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
CallsManager *
calls_manager_get_default (void)
{
static CallsManager *instance;
if (instance == NULL) {
instance = calls_manager_new ();
Uncrustify sources Ran `find src plugins -iname '*.[c|h]' -print0 | xargs -0 uncrustify --no-backup` with some minimal manual intervention.
2022-04-24 10:24:55 +00:00
g_object_add_weak_pointer (G_OBJECT (instance), (gpointer *) &instance);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
return instance;
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Contacts: replace CallsContacts with CallsContactsProvider
2021-01-20 14:20:09 +00:00
CallsContactsProvider *
calls_manager_get_contacts_provider (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
return self->contacts_provider;
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
void
calls_manager_add_provider (CallsManager *self,
const char *name)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_return_if_fail (CALLS_IS_MANAGER (self));
g_return_if_fail (name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
add_provider (self, name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
void
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
calls_manager_remove_provider (CallsManager *self,
const char *name)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
g_return_if_fail (CALLS_IS_MANAGER (self));
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_return_if_fail (name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
remove_provider (self, name);
}
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
gboolean
calls_manager_has_provider (CallsManager *self,
const char *name)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), FALSE);
g_return_val_if_fail (name, FALSE);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
return !!g_hash_table_lookup (self->providers, name);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
tests: manager: Add multiple provider tests The test suite can be further expanded later. For now this suffices to have some basic regression testing for multiple provider support in place.
2021-05-05 18:53:37 +00:00
gboolean
calls_manager_is_modem_provider (CallsManager *self,
const char *name)
{
CallsProvider *provider;
g_return_val_if_fail (CALLS_IS_MANAGER (self), FALSE);
g_return_val_if_fail (name, FALSE);
provider = g_hash_table_lookup (self->providers, name);
g_return_val_if_fail (provider, FALSE);
return calls_provider_is_modem (provider);
}
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
CallsManagerFlags
calls_manager_get_state_flags (CallsManager *self)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
g_return_val_if_fail (CALLS_IS_MANAGER (self), CALLS_MANAGER_FLAGS_UNKNOWN);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: Use state flags instead of an enum and adapt to changes This gives us some more granularity and is overall a better fit than the states previously used. Closes #327
2022-01-26 13:18:24 +00:00
return self->state_flags;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
provider: Use GListModel to track origins And adapt to changes It's easier to track changes if we are using GListModel than a GList. Also, eventually we shall have multiple providers, and we can use GtkFlattenListModel to merge multiple origins without manually managing pointers ourself. Since several widgets has APIs to handle GListModels, it will also help us create widgets from GListModels easily.
2021-02-15 05:34:34 +00:00
GListModel *
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
calls_manager_get_origins (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
return G_LIST_MODEL (self->origins);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: Codestyle We use two empty lines between functions, unless they are documented with docstrings in which case there is only one empty line.
2021-12-27 14:17:19 +00:00
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
/**
* calls_manager_get_calls:
* @self: A #CallsManager
*
* Returns: (transfer container): Returns a list of all known calls.
* The calls are objects of type #CallsUiCallData. Use g_list_free() when
* done using the list.
*/
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
GList *
calls_manager_get_calls (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
return g_hash_table_get_values (self->calls);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
/**
* calls_manager_hang_up_all_calls:
* @self: a #CallsManager
*
* Hangs up on every call known to @self.
*/
void
calls_manager_hang_up_all_calls (CallsManager *self)
{
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
GListModel *origins;
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
GList *node;
CallsCall *call;
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
uint n_items;
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
g_return_if_fail (CALLS_IS_MANAGER (self));
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
origins = G_LIST_MODEL (self->origins);
n_items = g_list_model_get_n_items (origins);
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
for (uint i = 0; i < n_items; i++) {
g_autoptr (CallsOrigin) origin = g_list_model_get_item (origins, i);
g_autoptr (GList) calls = calls_origin_get_calls (origin);
for (node = calls; node; node = node->next) {
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
call = node->data;
g_debug ("Hanging up on call %s", calls_call_get_name (call));
calls_call_hang_up (call);
}
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
}
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
manager: Switch to CallsUiCallData
2022-02-01 05:08:12 +00:00
g_debug ("Hung up on all calls");
manager: add has_active_call() and hang_up_all_calls()
2021-01-11 23:50:28 +00:00
}
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
/**
* calls_manager_get_suitable_origins:
* @self: The #CallsManager
* @target: The target number/address
*
manager: Hardcode supported protocols and adapt to changes This simplifies the code quite a bit by removing the supported protocols from being determined dynamically via the loaded plugins. It was previously used to add/remove a GListStore to origins_by_protocol. This is a prerequisite for having per protocol dial actions.
2022-01-26 07:24:09 +00:00
* Returns (transfer none): A #GListModel of suitable origins as long
* as the protocol to be used for @target is supported, %NULL otherwise
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
*/
GListModel *
calls_manager_get_suitable_origins (CallsManager *self,
const char *target)
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
{
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
const char *protocol;
GListModel *model;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
g_return_val_if_fail (target, NULL);
origin: Add country-code property And add a binding in CallsManager for the default origin
2021-03-25 19:25:09 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
protocol = get_protocol_from_address_with_fallback (target);
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
model = g_hash_table_lookup (self->origins_by_protocol, protocol);
if (model && G_IS_LIST_MODEL (model))
return model;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
manager: support multiple providers This includes the following changes: - Introduce a `providers` hash table to keep track of multiple CallProvider's and remove the `provider` member - Remove `calls_manager_get_provider()` and `calls_manager_set_provider()` in favour of `calls_manager_add_provider()`, `calls_manager_remove_provider()` and `calls_manager_has_provider()` - Introduce a `origins` GListStore to keep track of available origins. `origins` is updated in `items_changed_cb()` when the origins of any CallsProvider are updated. - Adapt to changes with respect to `calls_manager_get_origins()`. - Introduce `origins_by_protocol` hash table to keep track of available origins per protocol. - Adjust tests - We temporarily break country code lookup which was handled previously with the "default-origin" mechanism. We will add it back to the CallsSettings class which will provide a better application-wide mechanism.
2021-04-13 09:36:58 +00:00
return NULL;
Add a CallsManager and move Provider handling to it The manager is a central place for handling data e.g. calls history and provider managment. This introduces only the base for feature work. Therefore it manages only the provider for now, but the manager isn't yet used anywhere. The propagets events from the provider and origins. It also adds a new signal called `error`. The `error` signal should be emited only when something went wrong and we need to inform the user about it, containing the message to be displayed to the user. Windows should connect to the event and display a in-app-notification on error. This event isn't emitted, because the plugins don't give us a usable error.
2020-03-17 15:29:43 +00:00
}
application: Don't add a provider if one is already present If we initially invoked `gnome-calls -p sip` and later invoke `gnome-calls sip:user@host` we don't expect to have the default MM provider added.
2021-04-16 17:12:27 +00:00
/**
* calls_manager_has_any_provider:
* @self: The #CallsManager
*
* Returns: %TRUE if any provider is loaded, %FALSE otherwise
*/
gboolean
calls_manager_has_any_provider (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), FALSE);
return !!g_hash_table_size (self->providers);
}
application: Allow invoking with multiple `-p` arguments When calls is invoked with one or more `--provider` arguments, the application will only load the providers specified by the command line. If no `--provider` argument is given, the application will instead fall back to loading providers defined in the settings (see next commit).
2021-06-09 12:19:27 +00:00
/**
* calls_manager_get_provider_names:
* @self: The #CallsManager
* @length: (optional) (out): the length of the returned array
*
* Retrieves the names of all providers loaded by @self, as an array.
*
* You should free the return value with g_free().
*
* Returns: (array length=length) (transfer container): a
* %NULL-terminated array containing the names of providers.
*/
const char **
calls_manager_get_provider_names (CallsManager *self,
guint *length)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
return (const char **) g_hash_table_get_keys_as_array (self->providers, length);
}
manager: Add API to query loaded providers
2021-07-03 23:41:35 +00:00
/**
* calls_manager_get_providers:
* @self: A #CallsManager
*
* Get the currently loaded providers
*
* Returns: (transfer container): A #GList of #CallsProvider.
* Use g_list_free() when done using the list.
*/
GList *
calls_manager_get_providers (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
return g_hash_table_get_values (self->providers);
}
Simplify country code handling
2021-09-23 07:32:37 +00:00
CallsSettings *
calls_manager_get_settings (CallsManager *self)
{
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
return self->settings;
}
ui-call-data: Provide API to get the name of the origin used This will be used as a fallback when displaying the call details (see #222).
2022-02-10 09:12:16 +00:00
/**
* calls_manager_get_origin_by_id:
* @self: The #CallsManager
* @origin_id: The id to use for the lookup
*
* Returns: (transfer none): The #CallsOrigin if found, %NULL otherwise
*/
CallsOrigin *
calls_manager_get_origin_by_id (CallsManager *self,
const char *origin_id)
{
uint n_origins;
g_return_val_if_fail (CALLS_IS_MANAGER (self), NULL);
manager: Don't raise critical when origin id lookup fails We don't store origin ids yet because https://gitlab.gnome.org/GNOME/calls/-/merge_requests/505 is pending on https://gitlab.gnome.org/GNOME/gom/-/merge_requests/12 and https://gitlab.gnome.org/GNOME/gom/-/merge_requests/13
2022-04-01 09:38:01 +00:00
/* TODO Turn this into a critical once https://gitlab.gnome.org/GNOME/calls/-/merge_requests/505 is in */
if (origin_id && *origin_id)
return NULL;
ui-call-data: Provide API to get the name of the origin used This will be used as a fallback when displaying the call details (see #222).
2022-02-10 09:12:16 +00:00
n_origins = g_list_model_get_n_items (G_LIST_MODEL (self->origins));
for (uint i = 0; i < n_origins; i++) {
g_autoptr (CallsOrigin) origin =
g_list_model_get_item (G_LIST_MODEL (self->origins), i);
g_autofree char *id = calls_origin_get_id (origin);
if (g_strcmp0 (id, origin_id) == 0)
return origin;
}
return NULL;
}
Reference in a new issue Copy permalink