From 8392f30388b04cd0ab8fd41bca9d7788249c1c1b Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Fri, 25 Apr 2025 21:32:14 -0500 Subject: base-call: split AT-specific call code into MMCallAt Signed-off-by: Dan Williams --- src/meson.build | 1 + src/mm-base-call.c | 320 +------------------ src/mm-broadband-modem.c | 21 +- src/mm-call-at.c | 422 +++++++++++++++++++++++++ src/mm-call-at.h | 60 ++++ src/plugins/cinterion/mm-shared-cinterion.c | 19 +- src/plugins/huawei/mm-broadband-modem-huawei.c | 15 +- src/plugins/ublox/mm-broadband-modem-ublox.c | 15 +- 8 files changed, 521 insertions(+), 352 deletions(-) create mode 100644 src/mm-call-at.c create mode 100644 src/mm-call-at.h diff --git a/src/meson.build b/src/meson.build index 10838cf1..6b727a1d 100644 --- a/src/meson.build +++ b/src/meson.build @@ -324,6 +324,7 @@ sources = files( 'mm-auth-provider.c', 'mm-base-bearer.c', 'mm-base-call.c', + 'mm-call-at.c', 'mm-base-cbm.c', 'mm-base-manager.c', 'mm-base-modem-at.c', diff --git a/src/mm-base-call.c b/src/mm-base-call.c index 6308fd18..e0158495 100644 --- a/src/mm-base-call.c +++ b/src/mm-base-call.c @@ -28,6 +28,7 @@ #include "mm-base-call.h" #include "mm-broadband-modem.h" +#include "mm-auth-provider.h" #include "mm-iface-modem.h" #include "mm-iface-modem-voice.h" #include "mm-base-modem-at.h" @@ -988,314 +989,6 @@ mm_base_call_received_dtmf (MMBaseCall *self, mm_gdbus_call_emit_dtmf_received (MM_GDBUS_CALL (self), dtmf); } -/*****************************************************************************/ -/* Start the CALL */ - -static gboolean -call_start_finish (MMBaseCall *self, - GAsyncResult *res, - GError **error) -{ - return g_task_propagate_boolean (G_TASK (res), error); -} - -static void -call_start_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - GError *error = NULL; - const gchar *response = NULL; - - response = mm_base_modem_at_command_finish (modem, res, &error); - - /* check response for error */ - if (response && response[0]) - error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, - "Couldn't start the call: Unhandled response '%s'", response); - - if (error) - g_task_return_error (task, error); - else - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -call_start (MMBaseCall *self, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GError *error = NULL; - GTask *task; - gchar *cmd; - MMIfacePortAt *port; - - task = g_task_new (self, NULL, callback, user_data); - - port = mm_base_modem_peek_best_at_port (MM_BASE_MODEM (self->priv->modem), &error); - if (!port) { - g_task_return_error (task, error); - g_object_unref (task); - return; - } - - cmd = g_strdup_printf ("ATD%s;", mm_gdbus_call_get_number (MM_GDBUS_CALL (self))); - mm_base_modem_at_command_full (self->priv->modem, - port, - cmd, - 90, - FALSE, /* no cached */ - FALSE, /* no raw */ - cancellable, - (GAsyncReadyCallback)call_start_ready, - task); - g_free (cmd); -} - -/*****************************************************************************/ -/* Accept the call */ - -static gboolean -call_accept_finish (MMBaseCall *self, - GAsyncResult *res, - GError **error) -{ - return g_task_propagate_boolean (G_TASK (res), error); -} - -static void -call_accept_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - GError *error = NULL; - const gchar *response; - - response = mm_base_modem_at_command_finish (modem, res, &error); - - /* check response for error */ - if (response && response[0]) - g_set_error (&error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, - "Couldn't accept the call: Unhandled response '%s'", response); - - if (error) - g_task_return_error (task, error); - else - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -call_accept (MMBaseCall *self, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GTask *task; - - task = g_task_new (self, NULL, callback, user_data); - mm_base_modem_at_command (self->priv->modem, - "ATA", - 2, - FALSE, - (GAsyncReadyCallback)call_accept_ready, - task); -} - -/*****************************************************************************/ -/* Deflect the call */ - -static gboolean -call_deflect_finish (MMBaseCall *self, - GAsyncResult *res, - GError **error) -{ - return g_task_propagate_boolean (G_TASK (res), error); -} - -static void -call_deflect_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - GError *error = NULL; - - mm_base_modem_at_command_finish (modem, res, &error); - if (error) - g_task_return_error (task, error); - else - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -call_deflect (MMBaseCall *self, - const gchar *number, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GTask *task; - gchar *cmd; - - task = g_task_new (self, NULL, callback, user_data); - - cmd = g_strdup_printf ("+CTFR=%s", number); - mm_base_modem_at_command (self->priv->modem, - cmd, - 20, - FALSE, - (GAsyncReadyCallback)call_deflect_ready, - task); - g_free (cmd); -} - -/*****************************************************************************/ -/* Hangup the call */ - -static gboolean -call_hangup_finish (MMBaseCall *self, - GAsyncResult *res, - GError **error) -{ - return g_task_propagate_boolean (G_TASK (res), error); -} - -static void -chup_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - GError *error = NULL; - - mm_base_modem_at_command_finish (modem, res, &error); - if (error) - g_task_return_error (task, error); - else - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -chup_fallback (GTask *task) -{ - MMBaseCall *self; - - self = g_task_get_source_object (task); - mm_base_modem_at_command (self->priv->modem, - "+CHUP", - 2, - FALSE, - (GAsyncReadyCallback)chup_ready, - task); -} - -static void -chld_hangup_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - MMBaseCall *self; - GError *error = NULL; - - self = g_task_get_source_object (task); - - mm_base_modem_at_command_finish (modem, res, &error); - if (error) { - mm_obj_warn (self, "couldn't hangup single call with call id '%u': %s", - self->priv->index, error->message); - g_error_free (error); - chup_fallback (task); - return; - } - - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -call_hangup (MMBaseCall *self, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GTask *task; - - task = g_task_new (self, NULL, callback, user_data); - - /* Try to hangup the single call id */ - if (self->priv->index) { - gchar *cmd; - - cmd = g_strdup_printf ("+CHLD=1%u", self->priv->index); - mm_base_modem_at_command (self->priv->modem, - cmd, - 2, - FALSE, - (GAsyncReadyCallback)chld_hangup_ready, - task); - g_free (cmd); - return; - } - - /* otherwise terminate all */ - chup_fallback (task); -} - -/*****************************************************************************/ -/* Send DTMF tone to call */ - -static gboolean -call_send_dtmf_finish (MMBaseCall *self, - GAsyncResult *res, - GError **error) -{ - return g_task_propagate_boolean (G_TASK (res), error); -} - -static void -call_send_dtmf_ready (MMBaseModem *modem, - GAsyncResult *res, - GTask *task) -{ - MMBaseCall *self; - GError *error = NULL; - - self = g_task_get_source_object (task); - - mm_base_modem_at_command_finish (modem, res, &error); - if (error) { - mm_obj_dbg (self, "couldn't send dtmf: %s", error->message); - g_task_return_error (task, error); - g_object_unref (task); - return; - } - - g_task_return_boolean (task, TRUE); - g_object_unref (task); -} - -static void -call_send_dtmf (MMBaseCall *self, - const gchar *dtmf, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GTask *task; - gchar *cmd; - - task = g_task_new (self, NULL, callback, user_data); - - cmd = g_strdup_printf ("AT+VTS=%c", dtmf[0]); - mm_base_modem_at_command (self->priv->modem, - cmd, - 3, - FALSE, - (GAsyncReadyCallback)call_send_dtmf_ready, - task); - - g_free (cmd); -} - /*****************************************************************************/ static gchar * @@ -1498,17 +1191,6 @@ mm_base_call_class_init (MMBaseCallClass *klass) object_class->finalize = finalize; object_class->dispose = dispose; - klass->start = call_start; - klass->start_finish = call_start_finish; - klass->accept = call_accept; - klass->accept_finish = call_accept_finish; - klass->deflect = call_deflect; - klass->deflect_finish = call_deflect_finish; - klass->hangup = call_hangup; - klass->hangup_finish = call_hangup_finish; - klass->send_dtmf = call_send_dtmf; - klass->send_dtmf_finish = call_send_dtmf_finish; - properties[PROP_CONNECTION] = g_param_spec_object (MM_BASE_CALL_CONNECTION, "Connection", diff --git a/src/mm-broadband-modem.c b/src/mm-broadband-modem.c index 3d02553d..3d9cec56 100644 --- a/src/mm-broadband-modem.c +++ b/src/mm-broadband-modem.c @@ -50,6 +50,7 @@ #include "mm-bearer-list.h" #include "mm-cbm-list.h" #include "mm-cbm-part.h" +#include "mm-call-at.h" #include "mm-sms-list.h" #include "mm-sms-part-3gpp.h" #include "mm-sms-at.h" @@ -8902,16 +8903,16 @@ modem_voice_create_call (MMIfaceModemVoice *_self, { MMBroadbandModem *self = MM_BROADBAND_MODEM (_self); - return mm_base_call_new (MM_BASE_MODEM (self), - G_OBJECT (self), - direction, - number, - /* If +CLCC is supported, we want no incoming timeout. - * Also, we're able to support detailed call state updates without - * additional vendor-specific commands. */ - self->priv->clcc_supported, /* skip incoming timeout */ - self->priv->clcc_supported, /* dialing->ringing supported */ - self->priv->clcc_supported); /* ringing->active supported */ + return mm_call_at_new (MM_BASE_MODEM (self), + G_OBJECT (self), + direction, + number, + /* If +CLCC is supported, we want no incoming timeout. + * Also, we're able to support detailed call state updates without + * additional vendor-specific commands. */ + self->priv->clcc_supported, /* skip incoming timeout */ + self->priv->clcc_supported, /* dialing->ringing supported */ + self->priv->clcc_supported); /* ringing->active supported */ } /*****************************************************************************/ diff --git a/src/mm-call-at.c b/src/mm-call-at.c new file mode 100644 index 00000000..65cb3b7e --- /dev/null +++ b/src/mm-call-at.c @@ -0,0 +1,422 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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: + * + * Copyright (C) 2015 Riccardo Vangelisti + * Copyright (C) 2019 Aleksander Morgado + * Copyright (C) 2019 Purism SPC + */ + +#include +#include +#include +#include +#include +#include + +#include +#define _LIBMM_INSIDE_MM +#include + +#include "mm-call-at.h" +#include "mm-base-modem-at.h" +#include "mm-base-modem.h" +#include "mm-modem-helpers.h" +#include "mm-error-helpers.h" +#include "mm-log-object.h" +#include "mm-bind.h" + +G_DEFINE_TYPE (MMCallAt, mm_call_at, MM_TYPE_BASE_CALL) + +struct _MMCallAtPrivate { + /* The modem which owns this call */ + MMBaseModem *modem; +}; + +/*****************************************************************************/ +/* Start the CALL */ + +static gboolean +call_start_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void +call_start_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + GError *error = NULL; + const gchar *response = NULL; + + response = mm_base_modem_at_command_finish (modem, res, &error); + + /* check response for error */ + if (response && response[0]) + error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, + "Couldn't start the call: Unhandled response '%s'", response); + + if (error) + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +call_start (MMBaseCall *_self, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMCallAt *self = MM_CALL_AT (_self); + GError *error = NULL; + GTask *task; + gchar *cmd; + MMIfacePortAt *port; + + task = g_task_new (self, NULL, callback, user_data); + + port = mm_base_modem_peek_best_at_port (self->priv->modem, &error); + if (!port) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + cmd = g_strdup_printf ("ATD%s;", mm_gdbus_call_get_number (MM_GDBUS_CALL (self))); + mm_base_modem_at_command_full (self->priv->modem, + port, + cmd, + 90, + FALSE, /* no cached */ + FALSE, /* no raw */ + cancellable, + (GAsyncReadyCallback)call_start_ready, + task); + g_free (cmd); +} + +/*****************************************************************************/ +/* Accept the call */ + +static gboolean +call_accept_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void +call_accept_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + GError *error = NULL; + const gchar *response; + + response = mm_base_modem_at_command_finish (modem, res, &error); + + /* check response for error */ + if (response && response[0]) + g_set_error (&error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, + "Couldn't accept the call: Unhandled response '%s'", response); + + if (error) + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +call_accept (MMBaseCall *_self, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMCallAt *self = MM_CALL_AT (_self); + GTask *task; + + task = g_task_new (self, NULL, callback, user_data); + mm_base_modem_at_command (self->priv->modem, + "ATA", + 2, + FALSE, + (GAsyncReadyCallback)call_accept_ready, + task); +} + +/*****************************************************************************/ +/* Deflect the call */ + +static gboolean +call_deflect_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void +call_deflect_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + GError *error = NULL; + + mm_base_modem_at_command_finish (modem, res, &error); + if (error) + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +call_deflect (MMBaseCall *_self, + const gchar *number, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMCallAt *self = MM_CALL_AT (_self); + GTask *task; + gchar *cmd; + + task = g_task_new (self, NULL, callback, user_data); + + cmd = g_strdup_printf ("+CTFR=%s", number); + mm_base_modem_at_command (self->priv->modem, + cmd, + 20, + FALSE, + (GAsyncReadyCallback)call_deflect_ready, + task); + g_free (cmd); +} + +/*****************************************************************************/ +/* Hangup the call */ + +static gboolean +call_hangup_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void +chup_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + GError *error = NULL; + + mm_base_modem_at_command_finish (modem, res, &error); + if (error) + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +chup_fallback (GTask *task) +{ + MMCallAt *self; + + self = MM_CALL_AT (g_task_get_source_object (task)); + mm_base_modem_at_command (self->priv->modem, + "+CHUP", + 2, + FALSE, + (GAsyncReadyCallback)chup_ready, + task); +} + +static void +chld_hangup_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + MMBaseCall *self; + GError *error = NULL; + + self = g_task_get_source_object (task); + + mm_base_modem_at_command_finish (modem, res, &error); + if (error) { + mm_obj_warn (self, "couldn't hangup single call with call id '%u': %s", + mm_base_call_get_index (MM_BASE_CALL (self)), error->message); + g_error_free (error); + chup_fallback (task); + return; + } + + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +call_hangup (MMBaseCall *_self, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMCallAt *self = MM_CALL_AT (_self); + GTask *task; + guint index; + + task = g_task_new (self, NULL, callback, user_data); + + /* Try to hangup the single call id */ + index = mm_base_call_get_index (MM_BASE_CALL (self)); + if (index) { + gchar *cmd; + + cmd = g_strdup_printf ("+CHLD=1%u", index); + mm_base_modem_at_command (self->priv->modem, + cmd, + 2, + FALSE, + (GAsyncReadyCallback)chld_hangup_ready, + task); + g_free (cmd); + return; + } + + /* otherwise terminate all */ + chup_fallback (task); +} + +/*****************************************************************************/ +/* Send DTMF tone to call */ + +static gboolean +call_send_dtmf_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void +call_send_dtmf_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + MMBaseCall *self; + GError *error = NULL; + + self = g_task_get_source_object (task); + + mm_base_modem_at_command_finish (modem, res, &error); + if (error) { + mm_obj_dbg (self, "couldn't send dtmf: %s", error->message); + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + g_task_return_boolean (task, TRUE); + g_object_unref (task); +} + +static void +call_send_dtmf (MMBaseCall *_self, + const gchar *dtmf, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMCallAt *self = MM_CALL_AT (_self); + GTask *task; + gchar *cmd; + + task = g_task_new (self, NULL, callback, user_data); + + cmd = g_strdup_printf ("AT+VTS=%c", dtmf[0]); + mm_base_modem_at_command (self->priv->modem, + cmd, + 3, + FALSE, + (GAsyncReadyCallback)call_send_dtmf_ready, + task); + + g_free (cmd); +} + +/*****************************************************************************/ + +MMBaseCall * +mm_call_at_new (MMBaseModem *modem, + GObject *bind_to, + MMCallDirection direction, + const gchar *number, + gboolean skip_incoming_timeout, + gboolean supports_dialing_to_ringing, + gboolean supports_ringing_to_active) +{ + MMBaseCall *call; + + call = MM_BASE_CALL (g_object_new (MM_TYPE_CALL_AT, + MM_BASE_CALL_MODEM, modem, + MM_BIND_TO, bind_to, + "direction", direction, + "number", number, + MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, skip_incoming_timeout, + MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, supports_dialing_to_ringing, + MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, supports_ringing_to_active, + NULL)); + MM_CALL_AT (call)->priv->modem = g_object_ref (modem); + return call; +} + +static void +mm_call_at_init (MMCallAt *self) +{ + /* Initialize private data */ + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_CALL_AT, MMCallAtPrivate); +} + +static void +dispose (GObject *object) +{ + MMCallAt *self = MM_CALL_AT (object); + + g_clear_object (&self->priv->modem); + + G_OBJECT_CLASS (mm_call_at_parent_class)->dispose (object); +} + +static void +mm_call_at_class_init (MMCallAtClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + MMBaseCallClass *base_call_class = MM_BASE_CALL_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (MMCallAtPrivate)); + + object_class->dispose = dispose; + + base_call_class->start = call_start; + base_call_class->start_finish = call_start_finish; + base_call_class->accept = call_accept; + base_call_class->accept_finish = call_accept_finish; + base_call_class->deflect = call_deflect; + base_call_class->deflect_finish = call_deflect_finish; + base_call_class->hangup = call_hangup; + base_call_class->hangup_finish = call_hangup_finish; + base_call_class->send_dtmf = call_send_dtmf; + base_call_class->send_dtmf_finish = call_send_dtmf_finish; +} diff --git a/src/mm-call-at.h b/src/mm-call-at.h new file mode 100644 index 00000000..e1ae336e --- /dev/null +++ b/src/mm-call-at.h @@ -0,0 +1,60 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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: + * + * Copyright (C) 2015 Riccardo Vangelisti + * Copyright (C) 2019 Purism SPC + */ + +#ifndef MM_CALL_AT_H +#define MM_CALL_AT_H + +#include +#include + +#define _LIBMM_INSIDE_MM +#include + +#include "mm-base-call.h" +#include "mm-base-modem.h" + +#define MM_TYPE_CALL_AT (mm_call_at_get_type ()) +#define MM_CALL_AT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_CALL_AT, MMCallAt)) +#define MM_CALL_AT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MM_TYPE_CALL_AT, MMCallAtClass)) +#define MM_IS_CALL_AT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_CALL_AT)) +#define MM_IS_CALL_AT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MM_TYPE_CALL_AT)) +#define MM_CALL_AT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_CALL_AT, MMCallAtClass)) + +typedef struct _MMCallAt MMCallAt; +typedef struct _MMCallAtClass MMCallAtClass; +typedef struct _MMCallAtPrivate MMCallAtPrivate; + +struct _MMCallAt { + MMBaseCall parent; + MMCallAtPrivate *priv; +}; + +struct _MMCallAtClass { + MMBaseCallClass parent; +}; + +GType mm_call_at_get_type (void); +G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMCallAt, g_object_unref) + +MMBaseCall *mm_call_at_new (MMBaseModem *modem, + GObject *bind_to, + MMCallDirection direction, + const gchar *number, + gboolean skip_incoming_timeout, + gboolean supports_dialing_to_ringing, + gboolean supports_ringing_to_active); + +#endif /* MM_CALL_AT_H */ diff --git a/src/plugins/cinterion/mm-shared-cinterion.c b/src/plugins/cinterion/mm-shared-cinterion.c index 4ae1f503..60bbe6db 100644 --- a/src/plugins/cinterion/mm-shared-cinterion.c +++ b/src/plugins/cinterion/mm-shared-cinterion.c @@ -31,6 +31,7 @@ #include "mm-base-modem-at.h" #include "mm-shared-cinterion.h" #include "mm-modem-helpers-cinterion.h" +#include "mm-call-at.h" G_DEFINE_INTERFACE (MMSharedCinterion, mm_shared_cinterion, MM_TYPE_IFACE_MODEM) @@ -1005,15 +1006,15 @@ mm_shared_cinterion_create_call (MMIfaceModemVoice *self, priv = get_private (MM_SHARED_CINTERION (self)); if (priv->slcc_support == FEATURE_SUPPORTED) { mm_obj_dbg (self, "created new call with ^SLCC support"); - return mm_base_call_new (MM_BASE_MODEM (self), - G_OBJECT (self), - direction, - number, - /* When SLCC is supported we have support for detailed - * call list events via call list report URCs */ - TRUE, /* incoming timeout not required */ - TRUE, /* dialing->ringing supported */ - TRUE); /* ringing->active supported */ + return mm_call_at_new (MM_BASE_MODEM (self), + G_OBJECT (self), + direction, + number, + /* When SLCC is supported we have support for detailed + * call list events via call list report URCs */ + TRUE, /* incoming timeout not required */ + TRUE, /* dialing->ringing supported */ + TRUE); /* ringing->active supported */ } /* otherwise, run parent's generic base call logic */ diff --git a/src/plugins/huawei/mm-broadband-modem-huawei.c b/src/plugins/huawei/mm-broadband-modem-huawei.c index 5a7f2afc..76180a76 100644 --- a/src/plugins/huawei/mm-broadband-modem-huawei.c +++ b/src/plugins/huawei/mm-broadband-modem-huawei.c @@ -49,6 +49,7 @@ #include "mm-broadband-bearer.h" #include "mm-bearer-list.h" #include "mm-sim-huawei.h" +#include "mm-call-at.h" static void iface_modem_init (MMIfaceModemInterface *iface); static void iface_modem_3gpp_init (MMIfaceModem3gppInterface *iface); @@ -3880,13 +3881,13 @@ create_call (MMIfaceModemVoice *self, MMCallDirection direction, const gchar *number) { - return mm_base_call_new (MM_BASE_MODEM (self), - G_OBJECT (self), - direction, - number, - TRUE, /* skip_incoming_timeout */ - TRUE, /* supports_dialing_to_ringing */ - TRUE); /* supports_ringing_to_active) */ + return mm_call_at_new (MM_BASE_MODEM (self), + G_OBJECT (self), + direction, + number, + TRUE, /* skip_incoming_timeout */ + TRUE, /* supports_dialing_to_ringing */ + TRUE); /* supports_ringing_to_active) */ } /*****************************************************************************/ diff --git a/src/plugins/ublox/mm-broadband-modem-ublox.c b/src/plugins/ublox/mm-broadband-modem-ublox.c index 3c58adda..4213480e 100644 --- a/src/plugins/ublox/mm-broadband-modem-ublox.c +++ b/src/plugins/ublox/mm-broadband-modem-ublox.c @@ -33,6 +33,7 @@ #include "mm-sim-ublox.h" #include "mm-modem-helpers-ublox.h" #include "mm-ublox-enums-types.h" +#include "mm-call-at.h" static void iface_modem_init (MMIfaceModemInterface *iface); static void iface_modem_voice_init (MMIfaceModemVoiceInterface *iface); @@ -1505,13 +1506,13 @@ create_call (MMIfaceModemVoice *self, MMCallDirection direction, const gchar *number) { - return mm_base_call_new (MM_BASE_MODEM (self), - G_OBJECT (self), - direction, - number, - TRUE, /* skip_incoming_timeout */ - TRUE, /* supports_dialing_to_ringing */ - TRUE); /* supports_ringing_to_active */ + return mm_call_at_new (MM_BASE_MODEM (self), + G_OBJECT (self), + direction, + number, + TRUE, /* skip_incoming_timeout */ + TRUE, /* supports_dialing_to_ringing */ + TRUE); /* supports_ringing_to_active */ } /*****************************************************************************/ -- cgit v1.2.3-70-g09d2 From b9c49c7b4dd93d3f66f27cc13110ba672f7862df Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Sat, 26 Apr 2025 06:21:20 -0500 Subject: base-call: remove usage of MMBaseModem Split out the things we actually use from MMBaseModem into separate properties that can be independently implemented (or just left NULL) for unit tests. Signed-off-by: Dan Williams --- src/mm-base-call.c | 61 ++++++++++++++++-------------------------------------- src/mm-base-call.h | 13 ++---------- src/mm-call-at.c | 8 +++---- src/mm-call-qmi.c | 43 ++++++++++++++++++++++++++++---------- src/mm-call-qmi.h | 2 ++ 5 files changed, 58 insertions(+), 69 deletions(-) diff --git a/src/mm-base-call.c b/src/mm-base-call.c index e0158495..a59aca85 100644 --- a/src/mm-base-call.c +++ b/src/mm-base-call.c @@ -29,10 +29,7 @@ #include "mm-base-call.h" #include "mm-broadband-modem.h" #include "mm-auth-provider.h" -#include "mm-iface-modem.h" #include "mm-iface-modem-voice.h" -#include "mm-base-modem-at.h" -#include "mm-base-modem.h" #include "mm-log-object.h" #include "mm-modem-helpers.h" #include "mm-error-helpers.h" @@ -50,7 +47,7 @@ enum { PROP_PATH, PROP_CONNECTION, PROP_BIND_TO, - PROP_MODEM, + PROP_IFACE_MODEM_VOICE, PROP_SKIP_INCOMING_TIMEOUT, PROP_SUPPORTS_DIALING_TO_RINGING, PROP_SUPPORTS_RINGING_TO_ACTIVE, @@ -71,8 +68,8 @@ struct _MMBaseCallPrivate { /* The object this Call is bound to */ GObject *bind_to; - /* The modem which owns this call */ - MMBaseModem *modem; + /* The voice interface which owns this call */ + MMIfaceModemVoice *iface; /* The path where the call object is exported */ gchar *path; /* Features */ @@ -240,7 +237,7 @@ handle_start_auth_ready (MMAuthProvider *authp, mm_obj_info (ctx->self, "processing user request to start voice call..."); /* Disallow non-emergency calls when in emergency-only state */ - if (!mm_iface_modem_voice_authorize_outgoing_call (MM_IFACE_MODEM_VOICE (ctx->self->priv->modem), ctx->self, &error)) { + if (!mm_iface_modem_voice_authorize_outgoing_call (ctx->self->priv->iface, ctx->self, &error)) { mm_base_call_change_state (ctx->self, MM_CALL_STATE_TERMINATED, MM_CALL_STATE_REASON_UNKNOWN); mm_dbus_method_invocation_take_error (ctx->invocation, error); handle_start_context_free (ctx); @@ -535,7 +532,7 @@ handle_join_multiparty_auth_ready (MMAuthProvider *authp, /* This action is provided in the Call API, but implemented in the Modem.Voice interface * logic, because the action affects not only one call object, but all call objects that * are part of the multiparty call. */ - mm_iface_modem_voice_join_multiparty (MM_IFACE_MODEM_VOICE (ctx->self->priv->modem), + mm_iface_modem_voice_join_multiparty (ctx->self->priv->iface, ctx->self, (GAsyncReadyCallback)modem_voice_join_multiparty_ready, ctx); @@ -609,7 +606,7 @@ handle_leave_multiparty_auth_ready (MMAuthProvider *authp, /* This action is provided in the Call API, but implemented in the Modem.Voice interface * logic, because the action affects not only one call object, but all call objects that * are part of the multiparty call. */ - mm_iface_modem_voice_leave_multiparty (MM_IFACE_MODEM_VOICE (ctx->self->priv->modem), + mm_iface_modem_voice_leave_multiparty (ctx->self->priv->iface, ctx->self, (GAsyncReadyCallback)modem_voice_leave_multiparty_ready, ctx); @@ -1002,28 +999,6 @@ log_object_build_id (MMLogObject *_self) /*****************************************************************************/ -MMBaseCall * -mm_base_call_new (MMBaseModem *modem, - GObject *bind_to, - MMCallDirection direction, - const gchar *number, - gboolean skip_incoming_timeout, - gboolean supports_dialing_to_ringing, - gboolean supports_ringing_to_active) -{ - return MM_BASE_CALL (g_object_new (MM_TYPE_BASE_CALL, - MM_BASE_CALL_MODEM, modem, - MM_BIND_TO, bind_to, - "direction", direction, - "number", number, - MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, skip_incoming_timeout, - MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, supports_dialing_to_ringing, - MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, supports_ringing_to_active, - NULL)); -} - -/*****************************************************************************/ - static void set_property (GObject *object, guint prop_id, @@ -1058,9 +1033,9 @@ set_property (GObject *object, self->priv->bind_to = g_value_dup_object (value); mm_bind_to (MM_BIND (self), MM_BASE_CALL_CONNECTION, self->priv->bind_to); break; - case PROP_MODEM: - g_clear_object (&self->priv->modem); - self->priv->modem = g_value_dup_object (value); + case PROP_IFACE_MODEM_VOICE: + g_clear_object (&self->priv->iface); + self->priv->iface = g_value_dup_object (value); break; case PROP_SKIP_INCOMING_TIMEOUT: self->priv->skip_incoming_timeout = g_value_get_boolean (value); @@ -1095,8 +1070,8 @@ get_property (GObject *object, case PROP_BIND_TO: g_value_set_object (value, self->priv->bind_to); break; - case PROP_MODEM: - g_value_set_object (value, self->priv->modem); + case PROP_IFACE_MODEM_VOICE: + g_value_set_object (value, self->priv->iface); break; case PROP_SKIP_INCOMING_TIMEOUT: g_value_set_boolean (value, self->priv->skip_incoming_timeout); @@ -1159,7 +1134,7 @@ dispose (GObject *object) g_clear_object (&self->priv->connection); } - g_clear_object (&self->priv->modem); + g_clear_object (&self->priv->iface); g_clear_object (&self->priv->bind_to); g_cancellable_cancel (self->priv->authp_cancellable); g_clear_object (&self->priv->authp_cancellable); @@ -1209,13 +1184,13 @@ mm_base_call_class_init (MMBaseCallClass *klass) g_object_class_override_property (object_class, PROP_BIND_TO, MM_BIND_TO); - properties[PROP_MODEM] = - g_param_spec_object (MM_BASE_CALL_MODEM, - "Modem", - "The Modem which owns this call", - MM_TYPE_BASE_MODEM, + properties[PROP_IFACE_MODEM_VOICE] = + g_param_spec_object (MM_BASE_CALL_IFACE_MODEM_VOICE, + "Modem Voice Interface", + "The Modem voice interface which owns this call", + MM_TYPE_IFACE_MODEM_VOICE, G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_MODEM, properties[PROP_MODEM]); + g_object_class_install_property (object_class, PROP_IFACE_MODEM_VOICE, properties[PROP_IFACE_MODEM_VOICE]); properties[PROP_SKIP_INCOMING_TIMEOUT] = g_param_spec_boolean (MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, diff --git a/src/mm-base-call.h b/src/mm-base-call.h index fc69bf2f..a7666145 100644 --- a/src/mm-base-call.h +++ b/src/mm-base-call.h @@ -23,8 +23,8 @@ #define _LIBMM_INSIDE_MM #include -#include "mm-base-modem.h" #include "mm-call-audio-format.h" +#include "mm-port.h" #define MM_TYPE_BASE_CALL (mm_base_call_get_type ()) #define MM_BASE_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_BASE_CALL, MMBaseCall)) @@ -39,7 +39,7 @@ typedef struct _MMBaseCallPrivate MMBaseCallPrivate; #define MM_BASE_CALL_PATH "call-path" #define MM_BASE_CALL_CONNECTION "call-connection" -#define MM_BASE_CALL_MODEM "call-modem" +#define MM_BASE_CALL_IFACE_MODEM_VOICE "call-iface-modem-voice" #define MM_BASE_CALL_SKIP_INCOMING_TIMEOUT "call-skip-incoming-timeout" #define MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING "call-supports-dialing-to-ringing" #define MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE "call-supports-ringing-to-active" @@ -99,15 +99,6 @@ struct _MMBaseCallClass { GType mm_base_call_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMBaseCall, g_object_unref) -/* This one can be overridden by plugins */ -MMBaseCall *mm_base_call_new (MMBaseModem *modem, - GObject *bind_to, - MMCallDirection direction, - const gchar *number, - gboolean skip_incoming_timeout, - gboolean supports_dialing_to_ringing, - gboolean supports_ringing_to_active); - void mm_base_call_export (MMBaseCall *self); void mm_base_call_unexport (MMBaseCall *self); diff --git a/src/mm-call-at.c b/src/mm-call-at.c index 65cb3b7e..88bcb349 100644 --- a/src/mm-call-at.c +++ b/src/mm-call-at.c @@ -370,10 +370,10 @@ mm_call_at_new (MMBaseModem *modem, MMBaseCall *call; call = MM_BASE_CALL (g_object_new (MM_TYPE_CALL_AT, - MM_BASE_CALL_MODEM, modem, - MM_BIND_TO, bind_to, - "direction", direction, - "number", number, + MM_BASE_CALL_IFACE_MODEM_VOICE, modem, + MM_BIND_TO, bind_to, + "direction", direction, + "number", number, MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, skip_incoming_timeout, MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, supports_dialing_to_ringing, MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, supports_ringing_to_active, diff --git a/src/mm-call-qmi.c b/src/mm-call-qmi.c index 441be147..55bfa89a 100644 --- a/src/mm-call-qmi.c +++ b/src/mm-call-qmi.c @@ -35,6 +35,11 @@ G_DEFINE_TYPE (MMCallQmi, mm_call_qmi, MM_TYPE_BASE_CALL) +struct _MMCallQmiPrivate { + /* The modem which owns this call */ + MMBaseModem *modem; +}; + /*****************************************************************************/ static gboolean @@ -48,12 +53,7 @@ ensure_qmi_client (MMCallQmi *self, QmiClient *client; MMPortQmi *port; - g_object_get (self, - MM_BASE_CALL_MODEM, &modem, - NULL); - g_assert (MM_IS_BASE_MODEM (modem)); - - port = mm_broadband_modem_qmi_peek_port_qmi (MM_BROADBAND_MODEM_QMI (modem)); + port = mm_broadband_modem_qmi_peek_port_qmi (MM_BROADBAND_MODEM_QMI (self->priv->modem)); g_object_unref (modem); if (!port) { @@ -491,27 +491,48 @@ mm_call_qmi_new (MMBaseModem *modem, MMCallDirection direction, const gchar *number) { - return MM_BASE_CALL (g_object_new (MM_TYPE_CALL_QMI, - MM_BASE_CALL_MODEM, modem, - MM_BIND_TO, G_OBJECT (modem), - "direction", direction, - "number", number, + MMBaseCall *call; + + call = MM_BASE_CALL (g_object_new (MM_TYPE_CALL_QMI, + MM_BASE_CALL_IFACE_MODEM_VOICE, modem, + MM_BIND_TO, modem, + "direction", direction, + "number", number, MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, TRUE, MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, TRUE, MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, TRUE, NULL)); + MM_CALL_QMI (call)->priv->modem = g_object_ref (modem); + return call; } static void mm_call_qmi_init (MMCallQmi *self) { + /* Initialize private data */ + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_CALL_QMI, MMCallQmiPrivate); +} + +static void +dispose (GObject *object) +{ + MMCallQmi *self = MM_CALL_QMI (object); + + g_clear_object (&self->priv->modem); + + G_OBJECT_CLASS (mm_call_qmi_parent_class)->dispose (object); } static void mm_call_qmi_class_init (MMCallQmiClass *klass) { + GObjectClass *object_class = G_OBJECT_CLASS (klass); MMBaseCallClass *base_call_class = MM_BASE_CALL_CLASS (klass); + g_type_class_add_private (object_class, sizeof (MMCallQmiPrivate)); + + object_class->dispose = dispose; + base_call_class->start = call_start; base_call_class->start_finish = call_start_finish; base_call_class->accept = call_accept; diff --git a/src/mm-call-qmi.h b/src/mm-call-qmi.h index 78402539..34231bcc 100644 --- a/src/mm-call-qmi.h +++ b/src/mm-call-qmi.h @@ -33,9 +33,11 @@ typedef struct _MMCallQmi MMCallQmi; typedef struct _MMCallQmiClass MMCallQmiClass; +typedef struct _MMCallQmiPrivate MMCallQmiPrivate; struct _MMCallQmi { MMBaseCall parent; + MMCallQmiPrivate *priv; }; struct _MMCallQmiClass { -- cgit v1.2.3-70-g09d2 From 28b195465422b63ccc77e1a8d9d21e8bb6f217e9 Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Tue, 29 Apr 2025 20:26:10 -0500 Subject: call-list: remove unused modem property Signed-off-by: Dan Williams --- src/mm-call-list.c | 65 ++-------------------------------------------- src/mm-call-list.h | 5 +--- src/mm-iface-modem-voice.c | 2 +- 3 files changed, 4 insertions(+), 68 deletions(-) diff --git a/src/mm-call-list.c b/src/mm-call-list.c index 66e8382c..5e303390 100644 --- a/src/mm-call-list.c +++ b/src/mm-call-list.c @@ -24,20 +24,12 @@ #define _LIBMM_INSIDE_MM #include -#include "mm-iface-modem-messaging.h" #include "mm-call-list.h" #include "mm-base-call.h" #include "mm-log.h" G_DEFINE_TYPE (MMCallList, mm_call_list, G_TYPE_OBJECT) -enum { - PROP_0, - PROP_MODEM, - PROP_LAST -}; -static GParamSpec *properties[PROP_LAST]; - enum { SIGNAL_CALL_ADDED, SIGNAL_CALL_DELETED, @@ -46,8 +38,6 @@ enum { static guint signals[SIGNAL_LAST]; struct _MMCallListPrivate { - /* The owner modem */ - MMBaseModem *modem; /* List of call objects */ GList *list; }; @@ -213,49 +203,10 @@ mm_call_list_add_call (MMCallList *self, /*****************************************************************************/ MMCallList * -mm_call_list_new (MMBaseModem *modem) +mm_call_list_new (void) { /* Create the object */ - return g_object_new (MM_TYPE_CALL_LIST, - MM_CALL_LIST_MODEM, modem, - NULL); -} - -static void -set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - MMCallList *self = MM_CALL_LIST (object); - - switch (prop_id) { - case PROP_MODEM: - g_clear_object (&self->priv->modem); - self->priv->modem = g_value_dup_object (value); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - MMCallList *self = MM_CALL_LIST (object); - - switch (prop_id) { - case PROP_MODEM: - g_value_set_object (value, self->priv->modem); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } + return g_object_new (MM_TYPE_CALL_LIST, NULL); } static void @@ -272,7 +223,6 @@ dispose (GObject *object) { MMCallList *self = MM_CALL_LIST (object); - g_clear_object (&self->priv->modem); g_list_free_full (self->priv->list, g_object_unref); self->priv->list = NULL; @@ -287,19 +237,8 @@ mm_call_list_class_init (MMCallListClass *klass) g_type_class_add_private (object_class, sizeof (MMCallListPrivate)); /* Virtual methods */ - object_class->get_property = get_property; - object_class->set_property = set_property; object_class->dispose = dispose; - /* Properties */ - properties[PROP_MODEM] = - g_param_spec_object (MM_CALL_LIST_MODEM, - "Modem", - "The Modem which owns this CALL list", - MM_TYPE_BASE_MODEM, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_MODEM, properties[PROP_MODEM]); - /* Signals */ signals[SIGNAL_CALL_ADDED] = g_signal_new (MM_CALL_ADDED, diff --git a/src/mm-call-list.h b/src/mm-call-list.h index f77a5b37..c1e86c0a 100644 --- a/src/mm-call-list.h +++ b/src/mm-call-list.h @@ -19,7 +19,6 @@ #include #include -#include "mm-base-modem.h" #include "mm-base-call.h" #define MM_TYPE_CALL_LIST (mm_call_list_get_type ()) @@ -33,8 +32,6 @@ typedef struct _MMCallList MMCallList; typedef struct _MMCallListClass MMCallListClass; typedef struct _MMCallListPrivate MMCallListPrivate; -#define MM_CALL_LIST_MODEM "call-list-modem" - #define MM_CALL_ADDED "call-added" #define MM_CALL_DELETED "call-deleted" @@ -57,7 +54,7 @@ struct _MMCallListClass { GType mm_call_list_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMCallList, g_object_unref) -MMCallList *mm_call_list_new (MMBaseModem *modem); +MMCallList *mm_call_list_new (void); GStrv mm_call_list_get_paths (MMCallList *self); guint mm_call_list_get_count (MMCallList *self); diff --git a/src/mm-iface-modem-voice.c b/src/mm-iface-modem-voice.c index bca51c83..2ce0ec6b 100644 --- a/src/mm-iface-modem-voice.c +++ b/src/mm-iface-modem-voice.c @@ -3012,7 +3012,7 @@ interface_initialization_step (GTask *task) /* Create a new call list if not already available (this initialization * may be called multiple times) */ if (!list) { - list = mm_call_list_new (MM_BASE_MODEM (self)); + list = mm_call_list_new (); g_object_set (self, MM_IFACE_MODEM_VOICE_CALL_LIST, list, NULL); -- cgit v1.2.3-70-g09d2 From 5448a85a2bae32b6c9dfb82ac148904bf20fc209 Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Fri, 11 Apr 2025 20:43:17 -0500 Subject: call: allow setting DTMF tone duration at call creation time Instead of hard-coding a 500ms DTMF tone duration, let applications use a specific duration at call setup time. Signed-off-by: Dan Williams --- .../org.freedesktop.ModemManager1.Call.xml | 17 ++++- libmm-glib/mm-call-properties.c | 81 +++++++++++++++++++++- libmm-glib/mm-call-properties.h | 4 ++ src/mm-base-call.c | 14 ++++ src/mm-base-call.h | 9 +++ src/mm-broadband-modem-qmi.c | 6 +- src/mm-broadband-modem.c | 4 +- src/mm-call-at.c | 73 ++++++++++++++++--- src/mm-call-at.h | 1 + src/mm-call-qmi.c | 21 ++++-- src/mm-call-qmi.h | 3 +- src/mm-iface-modem-voice.c | 10 ++- src/mm-iface-modem-voice.h | 3 +- src/mm-modem-helpers.c | 16 +++++ src/mm-modem-helpers.h | 5 ++ src/plugins/cinterion/mm-shared-cinterion.c | 6 +- src/plugins/cinterion/mm-shared-cinterion.h | 3 +- src/plugins/huawei/mm-broadband-modem-huawei.c | 4 +- src/plugins/ublox/mm-broadband-modem-ublox.c | 4 +- 19 files changed, 249 insertions(+), 35 deletions(-) diff --git a/introspection/org.freedesktop.ModemManager1.Call.xml b/introspection/org.freedesktop.ModemManager1.Call.xml index 3aa6a643..85db4ad2 100644 --- a/introspection/org.freedesktop.ModemManager1.Call.xml +++ b/introspection/org.freedesktop.ModemManager1.Call.xml @@ -105,7 +105,7 @@ SendDtmf: @dtmf: DTMF tone identifier [0-9A-D*#]. - Send a DTMF tone (Dual Tone Multi-Frequency) (only on supported modem). + Send a DTMF tone (Dual Tone Multi-Frequency) (only on supported modems). Applicable only if state is MM_CALL_STATE_ACTIVE. @@ -119,7 +119,7 @@ DtmfReceived: @dtmf: DTMF tone identifier [0-9A-D*#]. - Emitted when a DTMF tone is received (only on supported modem) + Emitted when a DTMF tone is received (only on supported modems) Since: 1.6 --> @@ -232,5 +232,18 @@ Since: 1.10 --> + + + diff --git a/libmm-glib/mm-call-properties.c b/libmm-glib/mm-call-properties.c index c5da4920..ff486aa5 100644 --- a/libmm-glib/mm-call-properties.c +++ b/libmm-glib/mm-call-properties.c @@ -44,10 +44,12 @@ G_DEFINE_TYPE (MMCallProperties, mm_call_properties, G_TYPE_OBJECT) -#define PROPERTY_NUMBER "number" +#define PROPERTY_NUMBER "number" +#define PROPERTY_DTMF_TONE_DURATION "dtmf-tone-duration" struct _MMCallPropertiesPrivate { gchar *number; + guint dtmf_tone_duration; }; /*****************************************************************************/ @@ -92,6 +94,43 @@ mm_call_properties_get_number (MMCallProperties *self) /*****************************************************************************/ +/** + * mm_call_properties_set_dtmf_tone_duration: + * @self: A #MMCallProperties. + * @duration_ms: The desired duration of DTMF tones in milliseconds. + * + * Sets the DTMF tone duration if supported by the modem. + * + * Since: 1.26 + */ +void +mm_call_properties_set_dtmf_tone_duration (MMCallProperties *self, + const guint duration_ms) +{ + g_return_if_fail (MM_IS_CALL_PROPERTIES (self)); + + self->priv->dtmf_tone_duration = duration_ms; +} + +/** + * mm_call_properties_get_dtmf_tone_duration: + * @self: A #MMCallProperties. + * + * Gets the desired DTMF tone duration in milliseconds. + * + * Returns: the DTMF tone duration in milliseconds. + * + * Since: 1.26 + */ +guint +mm_call_properties_get_dtmf_tone_duration (MMCallProperties *self) +{ + g_return_val_if_fail (MM_IS_CALL_PROPERTIES (self), 0); + + return self->priv->dtmf_tone_duration; +} + +/*****************************************************************************/ /* * mm_call_properties_get_dictionary: (skip) */ @@ -114,6 +153,12 @@ mm_call_properties_get_dictionary (MMCallProperties *self) PROPERTY_NUMBER, g_variant_new_string (self->priv->number)); + if (self->priv->dtmf_tone_duration) + g_variant_builder_add (&builder, + "{sv}", + PROPERTY_DTMF_TONE_DURATION, + g_variant_new_uint32 (self->priv->dtmf_tone_duration)); + return g_variant_ref_sink (g_variant_builder_end (&builder)); } @@ -126,6 +171,18 @@ consume_string (MMCallProperties *self, { if (g_str_equal (key, PROPERTY_NUMBER)) { mm_call_properties_set_number (self, value); + } else if (g_str_equal (key, PROPERTY_DTMF_TONE_DURATION)) { + guint num; + + if (!mm_get_uint_from_str (value, &num)) { + g_set_error (error, + MM_CORE_ERROR, + MM_CORE_ERROR_INVALID_ARGS, + "Failed to parse DTMF tone duration from value '%s'", + value); + return FALSE; + } + mm_call_properties_set_dtmf_tone_duration (self, num); } else { g_set_error (error, MM_CORE_ERROR, @@ -189,11 +246,29 @@ consume_variant (MMCallProperties *properties, GVariant *value, GError **error) { - if (g_str_equal (key, PROPERTY_NUMBER)) + if (g_str_equal (key, PROPERTY_NUMBER)) { + if (!g_variant_is_of_type (value, G_VARIANT_TYPE_STRING)) { + g_set_error_literal (error, + MM_CORE_ERROR, + MM_CORE_ERROR_INVALID_ARGS, + "Invalid properties dictionary; number not a string"); + return FALSE; + } mm_call_properties_set_number ( properties, g_variant_get_string (value, NULL)); - else { + } else if (g_str_equal (key, PROPERTY_DTMF_TONE_DURATION)) { + if (!g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32)) { + g_set_error_literal (error, + MM_CORE_ERROR, + MM_CORE_ERROR_INVALID_ARGS, + "Invalid properties dictionary; dtmf-tone-duration not a uint32"); + return FALSE; + } + mm_call_properties_set_dtmf_tone_duration ( + properties, + g_variant_get_uint32 (value)); + } else { /* Set error */ g_set_error (error, MM_CORE_ERROR, diff --git a/libmm-glib/mm-call-properties.h b/libmm-glib/mm-call-properties.h index 12b4e330..1329ee3b 100644 --- a/libmm-glib/mm-call-properties.h +++ b/libmm-glib/mm-call-properties.h @@ -68,6 +68,10 @@ void mm_call_properties_set_number (MMCallProperties *self, const gchar *text); const gchar *mm_call_properties_get_number (MMCallProperties *self); +void mm_call_properties_set_dtmf_tone_duration (MMCallProperties *self, + const guint duration_ms); +guint mm_call_properties_get_dtmf_tone_duration (MMCallProperties *self); + /*****************************************************************************/ /* ModemManager/libmm-glib/mmcli specific methods */ diff --git a/src/mm-base-call.c b/src/mm-base-call.c index a59aca85..72982b1d 100644 --- a/src/mm-base-call.c +++ b/src/mm-base-call.c @@ -922,6 +922,20 @@ mm_base_call_set_multiparty (MMBaseCall *self, return mm_gdbus_call_set_multiparty (MM_GDBUS_CALL (self), multiparty); } +guint +mm_base_call_get_dtmf_tone_duration (MMBaseCall *self) +{ + return mm_dtmf_duration_normalize (mm_gdbus_call_get_dtmf_tone_duration (MM_GDBUS_CALL (self))); +} + +void +mm_base_call_set_dtmf_tone_duration (MMBaseCall *self, + guint duration_ms) +{ + return mm_gdbus_call_set_dtmf_tone_duration (MM_GDBUS_CALL (self), + mm_dtmf_duration_normalize (duration_ms)); +} + /*****************************************************************************/ /* Current call index, only applicable while the call is ongoing * See 3GPP TS 22.030 [27], subclause 6.5.5.1. diff --git a/src/mm-base-call.h b/src/mm-base-call.h index a7666145..fb738630 100644 --- a/src/mm-base-call.h +++ b/src/mm-base-call.h @@ -37,6 +37,10 @@ typedef struct _MMBaseCall MMBaseCall; typedef struct _MMBaseCallClass MMBaseCallClass; typedef struct _MMBaseCallPrivate MMBaseCallPrivate; +#define MM_CALL_DIRECTION "direction" +#define MM_CALL_NUMBER "number" +#define MM_CALL_DTMF_TONE_DURATION "dtmf-tone-duration" + #define MM_BASE_CALL_PATH "call-path" #define MM_BASE_CALL_CONNECTION "call-connection" #define MM_BASE_CALL_IFACE_MODEM_VOICE "call-iface-modem-voice" @@ -129,4 +133,9 @@ void mm_base_call_received_dtmf (MMBaseCall *self, void mm_base_call_incoming_refresh (MMBaseCall *self); +guint mm_base_call_get_dtmf_tone_duration (MMBaseCall *self); + +void mm_base_call_set_dtmf_tone_duration (MMBaseCall *self, + guint duration_ms); + #endif /* MM_BASE_CALL_H */ diff --git a/src/mm-broadband-modem-qmi.c b/src/mm-broadband-modem-qmi.c index 1b9cf04f..80cf157d 100644 --- a/src/mm-broadband-modem-qmi.c +++ b/src/mm-broadband-modem-qmi.c @@ -12190,11 +12190,13 @@ modem_voice_load_call_list (MMIfaceModemVoice *self, static MMBaseCall * modem_voice_create_call (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { return mm_call_qmi_new (MM_BASE_MODEM (self), direction, - number); + number, + dtmf_tone_duration); } /*****************************************************************************/ diff --git a/src/mm-broadband-modem.c b/src/mm-broadband-modem.c index 3d9cec56..27ac8f56 100644 --- a/src/mm-broadband-modem.c +++ b/src/mm-broadband-modem.c @@ -8899,7 +8899,8 @@ modem_voice_disable_unsolicited_events (MMIfaceModemVoice *self, static MMBaseCall * modem_voice_create_call (MMIfaceModemVoice *_self, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { MMBroadbandModem *self = MM_BROADBAND_MODEM (_self); @@ -8907,6 +8908,7 @@ modem_voice_create_call (MMIfaceModemVoice *_self, G_OBJECT (self), direction, number, + dtmf_tone_duration, /* If +CLCC is supported, we want no incoming timeout. * Also, we're able to support detailed call state updates without * additional vendor-specific commands. */ diff --git a/src/mm-call-at.c b/src/mm-call-at.c index 88bcb349..0a81b929 100644 --- a/src/mm-call-at.c +++ b/src/mm-call-at.c @@ -36,9 +36,18 @@ G_DEFINE_TYPE (MMCallAt, mm_call_at, MM_TYPE_BASE_CALL) +typedef enum { + FEATURE_SUPPORT_UNKNOWN, + FEATURE_NOT_SUPPORTED, + FEATURE_SUPPORTED, +} FeatureSupport; + struct _MMCallAtPrivate { /* The modem which owns this call */ MMBaseModem *modem; + + /* DTMF support */ + FeatureSupport vtd_supported; }; /*****************************************************************************/ @@ -333,27 +342,67 @@ call_send_dtmf_ready (MMBaseModem *modem, g_object_unref (task); } +static void +send_dtmf_digit (MMCallAt *self, + GTask *task, + const gchar dtmf_digit) +{ + g_autofree gchar *cmd = NULL; + + cmd = g_strdup_printf ("AT+VTS=%c", dtmf_digit); + mm_base_modem_at_command (self->priv->modem, + cmd, + 3, + FALSE, + (GAsyncReadyCallback)call_send_dtmf_ready, + task); +} + +static void +call_dtmf_vtd_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + MMCallAt *self; + g_autoptr(GError) error = NULL; + gchar dtmf_digit; + + self = g_task_get_source_object (task); + + mm_base_modem_at_command_finish (modem, res, &error); + self->priv->vtd_supported = error ? FEATURE_NOT_SUPPORTED : FEATURE_SUPPORTED; + + dtmf_digit = (gchar) GPOINTER_TO_UINT (g_task_get_task_data (task)); + send_dtmf_digit (self, task, dtmf_digit); +} + static void call_send_dtmf (MMBaseCall *_self, const gchar *dtmf, GAsyncReadyCallback callback, gpointer user_data) { - MMCallAt *self = MM_CALL_AT (_self); - GTask *task; - gchar *cmd; + MMCallAt *self = MM_CALL_AT (_self); + GTask *task; + g_autofree gchar *cmd = NULL; task = g_task_new (self, NULL, callback, user_data); - cmd = g_strdup_printf ("AT+VTS=%c", dtmf[0]); + if (self->priv->vtd_supported == FEATURE_NOT_SUPPORTED) { + send_dtmf_digit (self, task, dtmf[0]); + return; + } + + g_task_set_task_data (task, GUINT_TO_POINTER (dtmf[0]), NULL); + + /* Otherwise try to set duration */ + cmd = g_strdup_printf ("AT+VTD=%u", mm_base_call_get_dtmf_tone_duration (_self)); mm_base_modem_at_command (self->priv->modem, cmd, 3, FALSE, - (GAsyncReadyCallback)call_send_dtmf_ready, + (GAsyncReadyCallback)call_dtmf_vtd_ready, task); - - g_free (cmd); } /*****************************************************************************/ @@ -363,6 +412,7 @@ mm_call_at_new (MMBaseModem *modem, GObject *bind_to, MMCallDirection direction, const gchar *number, + const guint dtmf_tone_duration, gboolean skip_incoming_timeout, gboolean supports_dialing_to_ringing, gboolean supports_ringing_to_active) @@ -370,10 +420,11 @@ mm_call_at_new (MMBaseModem *modem, MMBaseCall *call; call = MM_BASE_CALL (g_object_new (MM_TYPE_CALL_AT, - MM_BASE_CALL_IFACE_MODEM_VOICE, modem, - MM_BIND_TO, bind_to, - "direction", direction, - "number", number, + MM_BASE_CALL_IFACE_MODEM_VOICE, modem, + MM_BIND_TO, bind_to, + MM_CALL_DIRECTION, direction, + MM_CALL_NUMBER, number, + MM_CALL_DTMF_TONE_DURATION, dtmf_tone_duration, MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, skip_incoming_timeout, MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, supports_dialing_to_ringing, MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, supports_ringing_to_active, diff --git a/src/mm-call-at.h b/src/mm-call-at.h index e1ae336e..64aed048 100644 --- a/src/mm-call-at.h +++ b/src/mm-call-at.h @@ -53,6 +53,7 @@ MMBaseCall *mm_call_at_new (MMBaseModem *modem, GObject *bind_to, MMCallDirection direction, const gchar *number, + const guint dtmf_tone_duration, gboolean skip_incoming_timeout, gboolean supports_dialing_to_ringing, gboolean supports_ringing_to_active); diff --git a/src/mm-call-qmi.c b/src/mm-call-qmi.c index 55bfa89a..1a9b2dd7 100644 --- a/src/mm-call-qmi.c +++ b/src/mm-call-qmi.c @@ -402,9 +402,12 @@ voice_start_continuous_dtmf_ready (QmiClientVoice *client, GAsyncResult *res, GTask *task) { + MMCallQmi *self; g_autoptr(QmiMessageVoiceStartContinuousDtmfOutput) output = NULL; GError *error = NULL; + self = g_task_get_source_object (task); + output = qmi_client_voice_start_continuous_dtmf_finish (client, res, &error); if (!output) { g_prefix_error (&error, "QMI operation failed: "); @@ -420,8 +423,10 @@ voice_start_continuous_dtmf_ready (QmiClientVoice *client, return; } - /* Disable DTMF press after 500 ms */ - g_timeout_add (500, (GSourceFunc) voice_stop_continuous_dtmf, task); + /* Disable DTMF press after DTMF tone duration elapses */ + g_timeout_add (mm_base_call_get_dtmf_tone_duration (MM_BASE_CALL (self)), + (GSourceFunc) voice_stop_continuous_dtmf, + task); } static void @@ -489,15 +494,17 @@ call_send_dtmf (MMBaseCall *self, MMBaseCall * mm_call_qmi_new (MMBaseModem *modem, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { MMBaseCall *call; call = MM_BASE_CALL (g_object_new (MM_TYPE_CALL_QMI, - MM_BASE_CALL_IFACE_MODEM_VOICE, modem, - MM_BIND_TO, modem, - "direction", direction, - "number", number, + MM_BASE_CALL_IFACE_MODEM_VOICE, modem, + MM_BIND_TO, modem, + MM_CALL_DIRECTION, direction, + MM_CALL_NUMBER, number, + MM_CALL_DTMF_TONE_DURATION, dtmf_tone_duration, MM_BASE_CALL_SKIP_INCOMING_TIMEOUT, TRUE, MM_BASE_CALL_SUPPORTS_DIALING_TO_RINGING, TRUE, MM_BASE_CALL_SUPPORTS_RINGING_TO_ACTIVE, TRUE, diff --git a/src/mm-call-qmi.h b/src/mm-call-qmi.h index 34231bcc..f99e7e10 100644 --- a/src/mm-call-qmi.h +++ b/src/mm-call-qmi.h @@ -49,6 +49,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMCallQmi, g_object_unref) MMBaseCall *mm_call_qmi_new (MMBaseModem *modem, MMCallDirection direction, - const gchar *number); + const gchar *number, + const guint dtmf_tone_duration); #endif /* MM_CALL_QMI_H */ diff --git a/src/mm-iface-modem-voice.c b/src/mm-iface-modem-voice.c index 2ce0ec6b..0bba2a34 100644 --- a/src/mm-iface-modem-voice.c +++ b/src/mm-iface-modem-voice.c @@ -161,7 +161,7 @@ create_incoming_call (MMIfaceModemVoice *self, g_assert (MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call != NULL); - call = MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call (self, MM_CALL_DIRECTION_INCOMING, number); + call = MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call (self, MM_CALL_DIRECTION_INCOMING, number, 0); update_audio_settings_in_call (self, call); return call; } @@ -173,6 +173,7 @@ create_outgoing_call_from_properties (MMIfaceModemVoice *self, { MMBaseCall *call; const gchar *number; + guint dtmf_tone_duration; /* Don't create CALL from properties if either number is missing */ number = mm_call_properties_get_number (properties) ; @@ -184,9 +185,14 @@ create_outgoing_call_from_properties (MMIfaceModemVoice *self, return NULL; } + dtmf_tone_duration = mm_call_properties_get_dtmf_tone_duration (properties) ; + /* Create a call object as defined by the interface */ g_assert (MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call != NULL); - call = MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call (self, MM_CALL_DIRECTION_OUTGOING, number); + call = MM_IFACE_MODEM_VOICE_GET_IFACE (self)->create_call (self, + MM_CALL_DIRECTION_OUTGOING, + number, + dtmf_tone_duration); update_audio_settings_in_call (self, call); return call; } diff --git a/src/mm-iface-modem-voice.h b/src/mm-iface-modem-voice.h index 2d8b5160..716988d5 100644 --- a/src/mm-iface-modem-voice.h +++ b/src/mm-iface-modem-voice.h @@ -123,7 +123,8 @@ struct _MMIfaceModemVoiceInterface { /* Create call objects */ MMBaseCall * (* create_call) (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number); + const gchar *number, + const guint dtmf_tone_duration); /* Hold and accept */ void (* hold_and_accept) (MMIfaceModemVoice *self, diff --git a/src/mm-modem-helpers.c b/src/mm-modem-helpers.c index a79ca956..0e258e61 100644 --- a/src/mm-modem-helpers.c +++ b/src/mm-modem-helpers.c @@ -5871,3 +5871,19 @@ mm_parse_cpin_response (const gchar *response, return MM_MODEM_LOCK_UNKNOWN; } + +/*****************************************************************************/ + +guint +mm_dtmf_duration_normalize (guint duration_ms) +{ + /* Default to 500ms */ + if (duration_ms == 0) + return 500; + + /* round to next highest 100ms */ + if (duration_ms % 100) + duration_ms = ((duration_ms + 100) / 100) * 100; + + return CLAMP (duration_ms, 100, 1000); +} diff --git a/src/mm-modem-helpers.h b/src/mm-modem-helpers.h index eb62a551..74626c90 100644 --- a/src/mm-modem-helpers.h +++ b/src/mm-modem-helpers.h @@ -643,4 +643,9 @@ guint mm_string_uint_map_lookup (const MMStringUintMap *map, MMModemLock mm_parse_cpin_response (const gchar *response, gboolean expect_cpin_prefix); +/*****************************************************************************/ + +/* Helper to clamp duration and round to next 100ms */ +guint mm_dtmf_duration_normalize (guint duration_ms); + #endif /* MM_MODEM_HELPERS_H */ diff --git a/src/plugins/cinterion/mm-shared-cinterion.c b/src/plugins/cinterion/mm-shared-cinterion.c index 60bbe6db..aa9b6208 100644 --- a/src/plugins/cinterion/mm-shared-cinterion.c +++ b/src/plugins/cinterion/mm-shared-cinterion.c @@ -998,7 +998,8 @@ mm_shared_cinterion_enable_location_gathering (MMIfaceModemLocation *self, MMBaseCall * mm_shared_cinterion_create_call (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { Private *priv; @@ -1010,6 +1011,7 @@ mm_shared_cinterion_create_call (MMIfaceModemVoice *self, G_OBJECT (self), direction, number, + dtmf_tone_duration, /* When SLCC is supported we have support for detailed * call list events via call list report URCs */ TRUE, /* incoming timeout not required */ @@ -1020,7 +1022,7 @@ mm_shared_cinterion_create_call (MMIfaceModemVoice *self, /* otherwise, run parent's generic base call logic */ g_assert (priv->iface_modem_voice_parent); g_assert (priv->iface_modem_voice_parent->create_call); - return priv->iface_modem_voice_parent->create_call (self, direction, number); + return priv->iface_modem_voice_parent->create_call (self, direction, number, dtmf_tone_duration); } /*****************************************************************************/ diff --git a/src/plugins/cinterion/mm-shared-cinterion.h b/src/plugins/cinterion/mm-shared-cinterion.h index f330e328..146ae96a 100644 --- a/src/plugins/cinterion/mm-shared-cinterion.h +++ b/src/plugins/cinterion/mm-shared-cinterion.h @@ -105,7 +105,8 @@ gboolean mm_shared_cinterion_disable_location_gathering_finish (MMI MMBaseCall *mm_shared_cinterion_create_call (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number); + const gchar *number, + const guint dtmf_tone_duration); void mm_shared_cinterion_voice_check_support (MMIfaceModemVoice *self, GAsyncReadyCallback callback, diff --git a/src/plugins/huawei/mm-broadband-modem-huawei.c b/src/plugins/huawei/mm-broadband-modem-huawei.c index 76180a76..5de6c4d5 100644 --- a/src/plugins/huawei/mm-broadband-modem-huawei.c +++ b/src/plugins/huawei/mm-broadband-modem-huawei.c @@ -3879,12 +3879,14 @@ modem_voice_disable_unsolicited_events (MMIfaceModemVoice *self, static MMBaseCall * create_call (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { return mm_call_at_new (MM_BASE_MODEM (self), G_OBJECT (self), direction, number, + dtmf_tone_duration, TRUE, /* skip_incoming_timeout */ TRUE, /* supports_dialing_to_ringing */ TRUE); /* supports_ringing_to_active) */ diff --git a/src/plugins/ublox/mm-broadband-modem-ublox.c b/src/plugins/ublox/mm-broadband-modem-ublox.c index 4213480e..ab049024 100644 --- a/src/plugins/ublox/mm-broadband-modem-ublox.c +++ b/src/plugins/ublox/mm-broadband-modem-ublox.c @@ -1504,12 +1504,14 @@ modem_voice_setup_unsolicited_events (MMIfaceModemVoice *self, static MMBaseCall * create_call (MMIfaceModemVoice *self, MMCallDirection direction, - const gchar *number) + const gchar *number, + const guint dtmf_tone_duration) { return mm_call_at_new (MM_BASE_MODEM (self), G_OBJECT (self), direction, number, + dtmf_tone_duration, TRUE, /* skip_incoming_timeout */ TRUE, /* supports_dialing_to_ringing */ TRUE); /* supports_ringing_to_active */ -- cgit v1.2.3-70-g09d2 From 2726f8e8a28a802a880bdbf974f522ef02c27bea Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Thu, 24 Apr 2025 08:50:10 -0500 Subject: base-call: convert DTMF tone handling to a state machine Generalize the timeout/stop logic that QMI requires into the base call. We'll use this to implement the pause character (,) generically. Signed-off-by: Dan Williams --- src/mm-base-call.c | 270 +++++++++++++++++++++++++++++++++++++++++++++++++++-- src/mm-base-call.h | 24 +++-- src/mm-call-qmi.c | 169 ++++++++++++++++++--------------- 3 files changed, 371 insertions(+), 92 deletions(-) diff --git a/src/mm-base-call.c b/src/mm-base-call.c index 72982b1d..3f4e081a 100644 --- a/src/mm-base-call.c +++ b/src/mm-base-call.c @@ -89,6 +89,9 @@ struct _MMBaseCallPrivate { * 'terminated' is coming asynchronously (e.g. via in-call state * update notifications) */ GCancellable *start_cancellable; + + /* DTMF support */ + GQueue *dtmf_queue; }; /*****************************************************************************/ @@ -728,6 +731,239 @@ handle_hangup (MMBaseCall *self, /*****************************************************************************/ /* Send dtmf (DBus call handling) */ +typedef enum { + DTMF_STEP_FIRST, + DTMF_STEP_START, + DTMF_STEP_TIMEOUT, + DTMF_STEP_STOP, + DTMF_STEP_LAST, +} DtmfStep; + +typedef struct { + DtmfStep step; + GError *saved_error; + guint8 call_id; + gchar *dtmf; + guint timeout_id; +} SendDtmfContext; + +static void +send_dtmf_context_clear_timeout (SendDtmfContext *ctx) +{ + if (ctx->timeout_id) { + g_source_remove (ctx->timeout_id); + ctx->timeout_id = 0; + } +} + +static void +send_dtmf_context_free (SendDtmfContext *ctx) +{ + send_dtmf_context_clear_timeout (ctx); + g_free (ctx->dtmf); + g_assert (!ctx->saved_error); + g_slice_free (SendDtmfContext, ctx); +} + +static void send_dtmf_task_step_next (GTask *task); + +static void +stop_dtmf_ignore_ready (MMBaseCall *self, + GAsyncResult *res, + gpointer unused) +{ + /* Ignore the result and error */ + MM_BASE_CALL_GET_CLASS (self)->stop_dtmf_finish (self, res, NULL); +} + +static void +send_dtmf_task_cancel (GTask *task) +{ + MMBaseCall *self; + SendDtmfContext *ctx; + + ctx = g_task_get_task_data (task); + self = g_task_get_source_object (task); + + send_dtmf_context_clear_timeout (ctx); + if (ctx->step > DTMF_STEP_FIRST && ctx->step < DTMF_STEP_STOP) { + if (MM_BASE_CALL_GET_CLASS (self)->stop_dtmf) { + MM_BASE_CALL_GET_CLASS (self)->stop_dtmf (self, + (GAsyncReadyCallback)stop_dtmf_ignore_ready, + NULL); + } + } + g_assert (ctx->step != DTMF_STEP_LAST); + ctx->step = DTMF_STEP_LAST; + send_dtmf_task_step_next (task); +} + +static void +stop_dtmf_ready (MMBaseCall *self, + GAsyncResult *res, + GTask *task) +{ + SendDtmfContext *ctx; + GError *error = NULL; + gboolean success; + + ctx = g_task_get_task_data (task); + + success = MM_BASE_CALL_GET_CLASS (self)->stop_dtmf_finish (self, res, &error); + if (ctx->step == DTMF_STEP_STOP) { + if (!success) { + g_propagate_error (&ctx->saved_error, error); + ctx->step = DTMF_STEP_LAST; + } else + ctx->step++; + + send_dtmf_task_step_next (task); + } + + /* Balance stop_dtmf() */ + g_object_unref (task); +} + +static gboolean +dtmf_timeout (GTask *task) +{ + SendDtmfContext *ctx; + + ctx = g_task_get_task_data (task); + + send_dtmf_context_clear_timeout (ctx); + ctx->step++; + send_dtmf_task_step_next (task); + + return G_SOURCE_REMOVE; +} + +static void +send_dtmf_ready (MMBaseCall *self, + GAsyncResult *res, + GTask *task) +{ + SendDtmfContext *ctx; + GError *error = NULL; + gboolean success; + + ctx = g_task_get_task_data (task); + + success = MM_BASE_CALL_GET_CLASS (self)->send_dtmf_finish (self, res, &error); + if (ctx->step == DTMF_STEP_START) { + if (!success) { + g_propagate_error (&ctx->saved_error, error); + ctx->step = DTMF_STEP_LAST; + } else + ctx->step++; + + send_dtmf_task_step_next (task); + } + + /* Balance send_dtmf() */ + g_object_unref (task); +} + +static void +send_dtmf_task_step_next (GTask *task) +{ + SendDtmfContext *ctx; + gboolean need_stop; + MMBaseCall *self; + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + need_stop = MM_BASE_CALL_GET_CLASS (self)->stop_dtmf && + MM_BASE_CALL_GET_CLASS (self)->stop_dtmf_finish; + + switch (ctx->step) { + case DTMF_STEP_FIRST: + ctx->step++; + /* Fall through */ + case DTMF_STEP_START: + MM_BASE_CALL_GET_CLASS (self)->send_dtmf (self, + ctx->dtmf, + (GAsyncReadyCallback)send_dtmf_ready, + g_object_ref (task)); + break; + case DTMF_STEP_TIMEOUT: + if (need_stop) { + /* Disable DTMF press after DTMF tone duration elapses */ + ctx->timeout_id = g_timeout_add (mm_base_call_get_dtmf_tone_duration (self), + (GSourceFunc) dtmf_timeout, + task); + return; + } + /* Fall through */ + case DTMF_STEP_STOP: + if (need_stop) { + send_dtmf_context_clear_timeout (ctx); + MM_BASE_CALL_GET_CLASS (self)->stop_dtmf (self, + (GAsyncReadyCallback)stop_dtmf_ready, + g_object_ref (task)); + return; + } + /* Fall through */ + case DTMF_STEP_LAST: + send_dtmf_context_clear_timeout (ctx); + if (ctx->saved_error) + g_task_return_error (task, g_steal_pointer (&ctx->saved_error)); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); + + /* Start the next tone if any are queued */ + g_queue_remove (self->priv->dtmf_queue, task); + task = g_queue_peek_head (self->priv->dtmf_queue); + if (task) + send_dtmf_task_step_next (task); + break; + default: + g_assert_not_reached (); + } +} + +static gboolean +send_dtmf_task_finish (MMBaseCall *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static GTask * +send_dtmf_task_new (MMBaseCall *self, + const gchar *dtmf, + GAsyncReadyCallback callback, + gpointer user_data, + GError **error) +{ + GTask *task; + SendDtmfContext *ctx; + guint8 call_id; + + call_id = mm_base_call_get_index (self); + if (call_id == 0) { + g_set_error (error, + MM_CORE_ERROR, + MM_CORE_ERROR_INVALID_ARGS, + "Invalid call index"); + return NULL; + } + + task = g_task_new (self, NULL, callback, user_data); + ctx = g_slice_new0 (SendDtmfContext); + ctx->call_id = call_id; + ctx->dtmf = g_strdup (dtmf); + g_task_set_task_data (task, ctx, (GDestroyNotify) send_dtmf_context_free); + + return task; +} + +/*****************************************************************************/ +/* Send DTMF D-Bus request handling */ + typedef struct { MMBaseCall *self; GDBusMethodInvocation *invocation; @@ -750,7 +986,7 @@ handle_send_dtmf_ready (MMBaseCall *self, { GError *error = NULL; - if (!MM_BASE_CALL_GET_CLASS (self)->send_dtmf_finish (self, res, &error)) { + if (!send_dtmf_task_finish (self, res, &error)) { mm_dbus_method_invocation_take_error (ctx->invocation, error); } else { mm_gdbus_call_complete_send_dtmf (MM_GDBUS_CALL (ctx->self), ctx->invocation); @@ -764,8 +1000,9 @@ handle_send_dtmf_auth_ready (MMAuthProvider *authp, GAsyncResult *res, HandleSendDtmfContext *ctx) { - MMCallState state; - GError *error = NULL; + MMCallState state; + GError *error = NULL; + GTask *task; if (!mm_auth_provider_authorize_finish (authp, res, &error)) { mm_dbus_method_invocation_take_error (ctx->invocation, error); @@ -775,7 +1012,7 @@ handle_send_dtmf_auth_ready (MMAuthProvider *authp, state = mm_gdbus_call_get_state (MM_GDBUS_CALL (ctx->self)); - /* Check if we do support doing it */ + /* Check if we do support doing DTMF at all */ if (!MM_BASE_CALL_GET_CLASS (ctx->self)->send_dtmf || !MM_BASE_CALL_GET_CLASS (ctx->self)->send_dtmf_finish) { mm_dbus_method_invocation_return_error_literal (ctx->invocation, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, @@ -793,9 +1030,20 @@ handle_send_dtmf_auth_ready (MMAuthProvider *authp, } mm_obj_info (ctx->self, "processing user request to send DTMF..."); - MM_BASE_CALL_GET_CLASS (ctx->self)->send_dtmf (ctx->self, ctx->dtmf, - (GAsyncReadyCallback)handle_send_dtmf_ready, - ctx); + task = send_dtmf_task_new (ctx->self, + ctx->dtmf, + (GAsyncReadyCallback)handle_send_dtmf_ready, + ctx, + &error); + if (!task) { + mm_dbus_method_invocation_take_error (ctx->invocation, error); + handle_send_dtmf_context_free (ctx); + return; + } + + g_queue_push_tail (ctx->self->priv->dtmf_queue, task); + if (g_queue_get_length (ctx->self->priv->dtmf_queue) == 1) + send_dtmf_task_step_next (task); } static gboolean @@ -1116,6 +1364,8 @@ mm_base_call_init (MMBaseCall *self) /* Setup authorization provider */ self->priv->authp = mm_auth_provider_get (); self->priv->authp_cancellable = g_cancellable_new (); + + self->priv->dtmf_queue = g_queue_new (); } static void @@ -1123,6 +1373,9 @@ finalize (GObject *object) { MMBaseCall *self = MM_BASE_CALL (object); + g_assert (g_queue_get_length (self->priv->dtmf_queue) == 0); + g_queue_free (g_steal_pointer (&self->priv->dtmf_queue)); + g_assert (!self->priv->start_cancellable); g_free (self->priv->path); @@ -1153,6 +1406,9 @@ dispose (GObject *object) g_cancellable_cancel (self->priv->authp_cancellable); g_clear_object (&self->priv->authp_cancellable); + g_queue_foreach (self->priv->dtmf_queue, (GFunc) send_dtmf_task_cancel, NULL); + g_queue_clear (self->priv->dtmf_queue); + G_OBJECT_CLASS (mm_base_call_parent_class)->dispose (object); } diff --git a/src/mm-base-call.h b/src/mm-base-call.h index fb738630..2e45ca5f 100644 --- a/src/mm-base-call.h +++ b/src/mm-base-call.h @@ -90,14 +90,22 @@ struct _MMBaseCallClass { GAsyncResult *res, GError **error); - /* Send a DTMF tone */ - void (* send_dtmf) (MMBaseCall *self, - const gchar *dtmf, - GAsyncReadyCallback callback, - gpointer user_data); - gboolean (* send_dtmf_finish) (MMBaseCall *self, - GAsyncResult *res, - GError **error); + /* DTMF tone handling */ + void (* send_dtmf) (MMBaseCall *self, + const gchar *dtmf, + GAsyncReadyCallback callback, + gpointer user_data); + gboolean (* send_dtmf_finish) (MMBaseCall *self, + GAsyncResult *res, + GError **error); + + void (* stop_dtmf) (MMBaseCall *self, + GAsyncReadyCallback callback, + gpointer user_data); + gboolean (* stop_dtmf_finish) (MMBaseCall *self, + GAsyncResult *res, + GError **error); + }; GType mm_base_call_get_type (void); diff --git a/src/mm-call-qmi.c b/src/mm-call-qmi.c index 1a9b2dd7..b1b6746d 100644 --- a/src/mm-call-qmi.c +++ b/src/mm-call-qmi.c @@ -331,22 +331,41 @@ call_hangup (MMBaseCall *self, } /*****************************************************************************/ -/* Send DTMF character */ +/* DTMF handling */ -typedef struct { - QmiClient *client; - guint8 call_id; -} SendDtmfContext; - -static void -send_dtmf_context_free (SendDtmfContext *ctx) +static gboolean +get_client_and_call_id (MMCallQmi *self, + GAsyncReadyCallback callback, + gpointer user_data, + QmiClient **client, + guint *call_id) { - g_clear_object (&ctx->client); - g_slice_free (SendDtmfContext, ctx); + g_return_val_if_fail (client, FALSE); + g_return_val_if_fail (call_id, FALSE); + + /* Ensure Voice client */ + if (!ensure_qmi_client (self, + QMI_SERVICE_VOICE, client, + callback, user_data)) + return FALSE; + + *call_id = mm_base_call_get_index (MM_BASE_CALL (self)); + if (*call_id == 0) { + g_task_report_new_error (self, + callback, + user_data, + (gpointer) __func__, + MM_CORE_ERROR, + MM_CORE_ERROR_INVALID_ARGS, + "Invalid call index"); + return FALSE; + } + + return TRUE; } static gboolean -call_send_dtmf_finish (MMBaseCall *self, +call_stop_dtmf_finish (MMBaseCall *call, GAsyncResult *res, GError **error) { @@ -366,35 +385,59 @@ voice_stop_continuous_dtmf_ready (QmiClientVoice *client, g_prefix_error (&error, "QMI operation failed: "); g_task_return_error (task, error); } else if (!qmi_message_voice_stop_continuous_dtmf_output_get_result (output, &error)) { - g_prefix_error (&error, "Couldn't send DTMF character: "); + g_prefix_error (&error, "Couldn't stop DTMF character: "); g_task_return_error (task, error); } else { g_task_return_boolean (task, TRUE); } - g_object_unref (task); } -static gboolean -voice_stop_continuous_dtmf (GTask *task) +static void +call_stop_dtmf (MMBaseCall *_self, + GAsyncReadyCallback callback, + gpointer user_data) { - SendDtmfContext *ctx; - GError *error = NULL; - g_autoptr (QmiMessageVoiceStopContinuousDtmfInput) input = NULL; + MMCallQmi *self = MM_CALL_QMI (_self); + GTask *task; + QmiClient *client = NULL; + guint call_id = 0; + GError *error = NULL; + g_autoptr (QmiMessageVoiceStopContinuousDtmfInput) input = NULL; + + if (!get_client_and_call_id (self, + callback, + user_data, + &client, + &call_id)) + return; - ctx = g_task_get_task_data (task); + task = g_task_new (self, NULL, callback, user_data); input = qmi_message_voice_stop_continuous_dtmf_input_new (); - qmi_message_voice_stop_continuous_dtmf_input_set_data (input, ctx->call_id, &error); + if (!qmi_message_voice_stop_continuous_dtmf_input_set_data (input, + call_id, + &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } - qmi_client_voice_stop_continuous_dtmf (QMI_CLIENT_VOICE (ctx->client), + /* Stop sending DTMF tone */ + qmi_client_voice_stop_continuous_dtmf (QMI_CLIENT_VOICE (client), input, 5, NULL, (GAsyncReadyCallback) voice_stop_continuous_dtmf_ready, task); +} - return G_SOURCE_REMOVE; +static gboolean +call_send_dtmf_finish (MMBaseCall *call, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); } static void @@ -402,85 +445,55 @@ voice_start_continuous_dtmf_ready (QmiClientVoice *client, GAsyncResult *res, GTask *task) { - MMCallQmi *self; - g_autoptr(QmiMessageVoiceStartContinuousDtmfOutput) output = NULL; - GError *error = NULL; - - self = g_task_get_source_object (task); + g_autoptr (QmiMessageVoiceStartContinuousDtmfOutput) output = NULL; + GError *error = NULL; output = qmi_client_voice_start_continuous_dtmf_finish (client, res, &error); if (!output) { g_prefix_error (&error, "QMI operation failed: "); g_task_return_error (task, error); - g_object_unref (task); - return; - } - - if (!qmi_message_voice_start_continuous_dtmf_output_get_result (output, &error)) { + } else if (!qmi_message_voice_start_continuous_dtmf_output_get_result (output, &error)) { g_prefix_error (&error, "Couldn't send DTMF character: "); g_task_return_error (task, error); - g_object_unref (task); - return; + } else { + g_task_return_boolean (task, TRUE); } - - /* Disable DTMF press after DTMF tone duration elapses */ - g_timeout_add (mm_base_call_get_dtmf_tone_duration (MM_BASE_CALL (self)), - (GSourceFunc) voice_stop_continuous_dtmf, - task); + g_object_unref (task); } static void -call_send_dtmf (MMBaseCall *self, +call_send_dtmf (MMBaseCall *_self, const gchar *dtmf, GAsyncReadyCallback callback, gpointer user_data) { - GTask *task; - GError *error = NULL; - SendDtmfContext *ctx; - QmiClient *client = NULL; - guint8 call_id; - g_autoptr (QmiMessageVoiceStartContinuousDtmfInput) input = NULL; - - /* Ensure Voice client */ - if (!ensure_qmi_client (MM_CALL_QMI (self), - QMI_SERVICE_VOICE, &client, - callback, user_data)) + MMCallQmi *self = MM_CALL_QMI (_self); + GTask *task; + QmiClient *client = NULL; + guint call_id = 0; + GError *error = NULL; + g_autoptr (QmiMessageVoiceStartContinuousDtmfInput) input = NULL; + + if (!get_client_and_call_id (self, + callback, + user_data, + &client, + &call_id)) return; task = g_task_new (self, NULL, callback, user_data); - call_id = mm_base_call_get_index (self); - if (call_id == 0) { - g_task_return_new_error (task, - MM_CORE_ERROR, - MM_CORE_ERROR_INVALID_ARGS, - "Invalid call index"); - g_object_unref (task); - return; - } - - ctx = g_slice_new0 (SendDtmfContext); - ctx->client = g_object_ref (client); - ctx->call_id = call_id; - - g_task_set_task_data (task, ctx, (GDestroyNotify) send_dtmf_context_free); - - /* Send DTMF character as ASCII number */ input = qmi_message_voice_start_continuous_dtmf_input_new (); - qmi_message_voice_start_continuous_dtmf_input_set_data (input, - call_id, - (guint8) dtmf[0], - &error); - if (error) { - g_task_return_new_error (task, - MM_CORE_ERROR, - MM_CORE_ERROR_INVALID_ARGS, - "DTMF data build failed"); + if (!qmi_message_voice_start_continuous_dtmf_input_set_data (input, + call_id, + dtmf[0], + &error)) { + g_task_return_error (task, error); g_object_unref (task); return; } + /* Send DTMF character as ASCII number */ qmi_client_voice_start_continuous_dtmf (QMI_CLIENT_VOICE (client), input, 5, @@ -548,4 +561,6 @@ mm_call_qmi_class_init (MMCallQmiClass *klass) base_call_class->hangup_finish = call_hangup_finish; base_call_class->send_dtmf = call_send_dtmf; base_call_class->send_dtmf_finish = call_send_dtmf_finish; + base_call_class->stop_dtmf = call_stop_dtmf; + base_call_class->stop_dtmf_finish = call_stop_dtmf_finish; } -- cgit v1.2.3-70-g09d2 From 957a141e57e622a9d7eeac160d67be5b0b4cdf7c Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Thu, 24 Apr 2025 20:17:47 -0500 Subject: base-call: interpret DTMF character ',' as two-second pause Do what other dialers do and interpret ',' as a short pause, which helps handle automated menus. Signed-off-by: Dan Williams --- .../org.freedesktop.ModemManager1.Call.xml | 3 ++- src/mm-base-call.c | 27 ++++++++++++++-------- src/mm-base-call.h | 2 ++ 3 files changed, 22 insertions(+), 10 deletions(-) diff --git a/introspection/org.freedesktop.ModemManager1.Call.xml b/introspection/org.freedesktop.ModemManager1.Call.xml index 85db4ad2..41dc40f3 100644 --- a/introspection/org.freedesktop.ModemManager1.Call.xml +++ b/introspection/org.freedesktop.ModemManager1.Call.xml @@ -103,9 +103,10 @@