From 9830e3955a3e45ff82c1c76bcba3b53432eaa51e Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Fri, 18 Apr 2025 08:57:49 -0500 Subject: base-sms,sms-at: split AT-specific SMS code into MMSmsAt Simplify MMBaseSms (making it easier to use from testcases) by splitting the AT-specific code into MMSmsAt rather than keeping it in the base class. Signed-off-by: Dan Williams --- src/mm-sms-at.c | 835 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 835 insertions(+) create mode 100644 src/mm-sms-at.c (limited to 'src/mm-sms-at.c') diff --git a/src/mm-sms-at.c b/src/mm-sms-at.c new file mode 100644 index 00000000..3fc7c155 --- /dev/null +++ b/src/mm-sms-at.c @@ -0,0 +1,835 @@ +/* -*- 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) 2008 - 2009 Novell, Inc. + * Copyright (C) 2009 - 2012 Red Hat, Inc. + * Copyright (C) 2012 Google, Inc. + * Copyright (C) 2025 Dan Williams + */ + +#include +#include +#include +#include +#include +#include + +#include +#define _LIBMM_INSIDE_MM +#include + +#include "mm-sms-at.h" +#include "mm-iface-modem-messaging.h" +#include "mm-sms-part-3gpp.h" +#include "mm-base-modem-at.h" +#include "mm-log-object.h" + +G_DEFINE_TYPE (MMSmsAt, mm_sms_at, MM_TYPE_BASE_SMS) + +struct _MMSmsAtPrivate { + MMBaseModem *modem; +}; + +/*****************************************************************************/ + +static gboolean +sms_get_store_or_send_command (MMSmsAt *self, + MMSmsPart *part, + gboolean text_or_pdu, /* TRUE for PDU */ + gboolean store_or_send, /* TRUE for send */ + gchar **out_cmd, + gchar **out_msg_data, + GError **error) +{ + g_assert (out_cmd != NULL); + g_assert (out_msg_data != NULL); + + if (!text_or_pdu) { + /* Text mode */ + *out_cmd = g_strdup_printf ("+CMG%c=\"%s\"", + store_or_send ? 'S' : 'W', + mm_sms_part_get_number (part)); + *out_msg_data = g_strdup_printf ("%s\x1a", mm_sms_part_get_text (part)); + } else { + g_autofree gchar *hex = NULL; + g_autofree guint8 *pdu = NULL; + guint pdulen = 0; + guint msgstart = 0; + + /* AT+CMGW=[, ] PDU can be entered. / */ + + pdu = mm_sms_part_3gpp_get_submit_pdu (part, &pdulen, &msgstart, self, error); + if (!pdu) + /* 'error' should already be set */ + return FALSE; + + /* Convert PDU to hex */ + hex = mm_utils_bin2hexstr (pdu, pdulen); + if (!hex) { + g_set_error (error, + MM_CORE_ERROR, + MM_CORE_ERROR_FAILED, + "Not enough memory to send SMS PDU"); + return FALSE; + } + + /* CMGW/S length is the size of the PDU without SMSC information */ + *out_cmd = g_strdup_printf ("+CMG%c=%d", + store_or_send ? 'S' : 'W', + pdulen - msgstart); + *out_msg_data = g_strdup_printf ("%s\x1a", hex); + } + + return TRUE; +} + +/*****************************************************************************/ +/* Store the SMS */ + +typedef struct { + MMBaseModem *modem; + MMIfacePortAt *port; + MMSmsStorage storage; + gboolean need_unlock; + gboolean use_pdu_mode; + GList *current; + gchar *msg_data; +} SmsStoreContext; + +static void +sms_store_context_free (SmsStoreContext *ctx) +{ + /* Unlock mem2 storage if we had the lock */ + if (ctx->need_unlock) { + mm_iface_modem_messaging_unlock_storages (MM_IFACE_MODEM_MESSAGING (ctx->modem), + FALSE, + TRUE); + } + g_object_unref (ctx->port); + g_object_unref (ctx->modem); + g_free (ctx->msg_data); + g_slice_free (SmsStoreContext, ctx); +} + +static gboolean +sms_store_finish (MMBaseSms *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void sms_store_next_part (GTask *task); + +static void +store_msg_data_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + SmsStoreContext *ctx; + const gchar *response; + GError *error = NULL; + gint rv; + gint idx; + + response = mm_base_modem_at_command_full_finish (modem, res, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + /* Read the new part index from the reply */ + rv = sscanf (response, "+CMGW: %d", &idx); + if (rv != 1 || idx < 0) { + g_task_return_new_error (task, + MM_CORE_ERROR, + MM_CORE_ERROR_FAILED, + "Couldn't read index of already stored part: " + "%d fields parsed", + rv); + g_object_unref (task); + return; + } + + ctx = g_task_get_task_data (task); + + /* Set the index in the part we hold */ + mm_sms_part_set_index ((MMSmsPart *)ctx->current->data, (guint)idx); + + ctx->current = g_list_next (ctx->current); + sms_store_next_part (task); +} + +static void +store_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + SmsStoreContext *ctx; + GError *error = NULL; + + mm_base_modem_at_command_full_finish (modem, res, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + ctx = g_task_get_task_data (task); + + /* Send the actual message data. + * We send the data as 'raw' data because we do NOT want it to + * be treated as an AT command (i.e. we don't want it prefixed + * with AT+ and suffixed with ), plus, we want it to be + * sent right away (not queued after other AT commands). */ + mm_base_modem_at_command_full (ctx->modem, + ctx->port, + ctx->msg_data, + 10, + FALSE, + TRUE, /* raw */ + NULL, + (GAsyncReadyCallback)store_msg_data_ready, + task); +} + +static void +sms_store_next_part (GTask *task) +{ + MMSmsAt *self; + SmsStoreContext *ctx; + GError *error = NULL; + g_autofree gchar *cmd = NULL; + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + if (!ctx->current) { + /* Done we are */ + g_task_return_boolean (task, TRUE); + g_object_unref (task); + return; + } + + g_clear_pointer (&ctx->msg_data, g_free); + + if (!sms_get_store_or_send_command (self, + (MMSmsPart *)ctx->current->data, + ctx->use_pdu_mode, + FALSE, + &cmd, + &ctx->msg_data, + &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + g_assert (cmd != NULL); + g_assert (ctx->msg_data != NULL); + + mm_base_modem_at_command_full (ctx->modem, + ctx->port, + cmd, + 10, + FALSE, + FALSE, /* raw */ + NULL, + (GAsyncReadyCallback)store_ready, + task); +} + +static void +store_lock_sms_storages_ready (MMIfaceModemMessaging *messaging, + GAsyncResult *res, + GTask *task) +{ + MMSmsAt *self; + SmsStoreContext *ctx; + GError *error = NULL; + + if (!mm_iface_modem_messaging_lock_storages_finish (messaging, res, &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + /* We are now locked. Whatever result we have here, we need to make sure + * we unlock the storages before finishing. */ + ctx->need_unlock = TRUE; + + /* Go on to store the parts */ + ctx->current = mm_base_sms_get_parts (MM_BASE_SMS (self)); + sms_store_next_part (task); +} + +static void +sms_store (MMBaseSms *sms, + MMSmsStorage storage, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMSmsAt *self = MM_SMS_AT (sms); + SmsStoreContext *ctx; + GTask *task; + MMIfacePortAt *port; + GError *error = NULL; + + task = g_task_new (self, NULL, callback, user_data); + + /* Select port for the operation */ + 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; + } + + /* Setup the context */ + ctx = g_slice_new0 (SmsStoreContext); + ctx->modem = g_object_ref (self->priv->modem); + ctx->port = g_object_ref (port); + ctx->storage = storage; + + /* Different ways to do it if on PDU or text mode */ + g_assert (MM_IS_IFACE_MODEM_MESSAGING (self->priv->modem)); + g_object_get (self->priv->modem, + MM_IFACE_MODEM_MESSAGING_SMS_PDU_MODE, &ctx->use_pdu_mode, + NULL); + g_task_set_task_data (task, ctx, (GDestroyNotify)sms_store_context_free); + + /* First, lock storage to use */ + mm_iface_modem_messaging_lock_storages ( + MM_IFACE_MODEM_MESSAGING (self->priv->modem), + MM_SMS_STORAGE_UNKNOWN, /* none required for mem1 */ + ctx->storage, + (GAsyncReadyCallback)store_lock_sms_storages_ready, + task); +} + +/*****************************************************************************/ +/* Send the SMS */ + +typedef struct { + MMBaseModem *modem; + MMIfacePortAt *port; + gboolean need_unlock; + gboolean from_storage; + gboolean use_pdu_mode; + GList *current; + gchar *msg_data; +} SmsSendContext; + +static void +sms_send_context_free (SmsSendContext *ctx) +{ + /* Unlock mem2 storage if we had the lock */ + if (ctx->need_unlock) { + mm_iface_modem_messaging_unlock_storages (MM_IFACE_MODEM_MESSAGING (ctx->modem), + FALSE, + TRUE); + } + g_object_unref (ctx->port); + g_object_unref (ctx->modem); + g_free (ctx->msg_data); + g_slice_free (SmsSendContext, ctx); +} + +static gboolean +sms_send_finish (MMBaseSms *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void sms_send_next_part (GTask *task); + +static gint +read_message_reference_from_reply (const gchar *response, + GError **error) +{ + gint rv = 0; + gint idx = -1; + + if (strstr (response, "+CMGS")) + rv = sscanf (strstr (response, "+CMGS"), "+CMGS: %d", &idx); + else if (strstr (response, "+CMSS")) + rv = sscanf (strstr (response, "+CMSS"), "+CMSS: %d", &idx); + + if (rv != 1 || idx < 0) { + g_set_error (error, + MM_CORE_ERROR, + MM_CORE_ERROR_FAILED, + "Couldn't read message reference: " + "%d fields parsed from response '%s'", + rv, response); + return -1; + } + + return idx; +} + +static void +send_generic_msg_data_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + SmsSendContext *ctx; + GError *error = NULL; + const gchar *response; + gint message_reference; + + response = mm_base_modem_at_command_full_finish (modem, res, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + message_reference = read_message_reference_from_reply (response, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + ctx = g_task_get_task_data (task); + + mm_sms_part_set_message_reference ((MMSmsPart *)ctx->current->data, + (guint)message_reference); + + ctx->current = g_list_next (ctx->current); + sms_send_next_part (task); +} + +static void +send_generic_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + SmsSendContext *ctx; + GError *error = NULL; + + mm_base_modem_at_command_full_finish (modem, res, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + ctx = g_task_get_task_data (task); + + /* Send the actual message data. + * We send the data as 'raw' data because we do NOT want it to + * be treated as an AT command (i.e. we don't want it prefixed + * with AT+ and suffixed with ), plus, we want it to be + * sent right away (not queued after other AT commands). */ + mm_base_modem_at_command_full (ctx->modem, + ctx->port, + ctx->msg_data, + MM_BASE_SMS_DEFAULT_SEND_TIMEOUT, + FALSE, + TRUE, /* raw */ + NULL, + (GAsyncReadyCallback)send_generic_msg_data_ready, + task); +} + +static void +send_from_storage_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + MMSmsAt *self; + SmsSendContext *ctx; + GError *error = NULL; + const gchar *response; + gint message_reference; + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + response = mm_base_modem_at_command_full_finish (modem, res, &error); + if (error) { + if (g_error_matches (error, MM_SERIAL_ERROR, MM_SERIAL_ERROR_RESPONSE_TIMEOUT)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + mm_obj_dbg (self, "couldn't send SMS from storage: %s; trying generic send...", error->message); + g_error_free (error); + + ctx->from_storage = FALSE; + sms_send_next_part (task); + return; + } + + message_reference = read_message_reference_from_reply (response, &error); + if (error) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + mm_sms_part_set_message_reference ((MMSmsPart *)ctx->current->data, + (guint)message_reference); + + ctx->current = g_list_next (ctx->current); + sms_send_next_part (task); +} + +static void +sms_send_next_part (GTask *task) +{ + MMSmsAt *self; + SmsSendContext *ctx; + GError *error = NULL; + g_autofree gchar *cmd = NULL; + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + if (!ctx->current) { + /* Done we are */ + g_task_return_boolean (task, TRUE); + g_object_unref (task); + return; + } + + /* Send from storage */ + if (ctx->from_storage) { + cmd = g_strdup_printf ("+CMSS=%d", mm_sms_part_get_index ((MMSmsPart *)ctx->current->data)); + mm_base_modem_at_command_full (ctx->modem, + ctx->port, + cmd, + MM_BASE_SMS_DEFAULT_SEND_TIMEOUT, + FALSE, + FALSE, + NULL, + (GAsyncReadyCallback)send_from_storage_ready, + task); + return; + } + + /* Generic send */ + + g_clear_pointer (&ctx->msg_data, g_free); + + if (!sms_get_store_or_send_command (self, + (MMSmsPart *)ctx->current->data, + ctx->use_pdu_mode, + TRUE, + &cmd, + &ctx->msg_data, + &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + g_assert (cmd != NULL); + g_assert (ctx->msg_data != NULL); + + /* no network involved in this initial AT command, so lower timeout */ + mm_base_modem_at_command_full (ctx->modem, + ctx->port, + cmd, + 10, + FALSE, + FALSE, /* raw */ + NULL, + (GAsyncReadyCallback)send_generic_ready, + task); +} + +static void +send_lock_sms_storages_ready (MMIfaceModemMessaging *messaging, + GAsyncResult *res, + GTask *task) +{ + MMSmsAt *self; + SmsSendContext *ctx; + GError *error = NULL; + + if (!mm_iface_modem_messaging_lock_storages_finish (messaging, res, &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + /* We are now locked. Whatever result we have here, we need to make sure + * we unlock the storages before finishing. */ + ctx->need_unlock = TRUE; + + /* Go on to send the parts */ + ctx->current = mm_base_sms_get_parts (MM_BASE_SMS (self)); + sms_send_next_part (task); +} + +static void +sms_send (MMBaseSms *sms, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMSmsAt *self = MM_SMS_AT (sms); + SmsSendContext *ctx; + GTask *task; + MMIfacePortAt *port; + GError *error = NULL; + + task = g_task_new (self, NULL, callback, user_data); + + /* Select port for the operation */ + 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; + } + + /* Setup the context */ + ctx = g_slice_new0 (SmsSendContext); + ctx->modem = g_object_ref (self->priv->modem); + ctx->port = g_object_ref (port); + g_task_set_task_data (task, ctx, (GDestroyNotify)sms_send_context_free); + + /* If the SMS is STORED, try to send from storage */ + ctx->from_storage = (mm_base_sms_get_storage (MM_BASE_SMS (self)) != MM_SMS_STORAGE_UNKNOWN); + if (ctx->from_storage) { + /* When sending from storage, first lock storage to use */ + g_assert (MM_IS_IFACE_MODEM_MESSAGING (self->priv->modem)); + mm_iface_modem_messaging_lock_storages ( + MM_IFACE_MODEM_MESSAGING (self->priv->modem), + MM_SMS_STORAGE_UNKNOWN, /* none required for mem1 */ + mm_base_sms_get_storage (MM_BASE_SMS (self)), + (GAsyncReadyCallback)send_lock_sms_storages_ready, + task); + return; + } + + /* Different ways to do it if on PDU or text mode */ + g_object_get (self->priv->modem, + MM_IFACE_MODEM_MESSAGING_SMS_PDU_MODE, &ctx->use_pdu_mode, + NULL); + ctx->current = mm_base_sms_get_parts (MM_BASE_SMS (self)); + sms_send_next_part (task); +} + +/*****************************************************************************/ + +typedef struct { + MMBaseModem *modem; + gboolean need_unlock; + GList *current; + guint n_failed; +} SmsDeletePartsContext; + +static void +sms_delete_parts_context_free (SmsDeletePartsContext *ctx) +{ + /* Unlock mem1 storage if we had the lock */ + if (ctx->need_unlock) { + mm_iface_modem_messaging_unlock_storages (MM_IFACE_MODEM_MESSAGING (ctx->modem), + TRUE, + FALSE); + } + g_object_unref (ctx->modem); + g_slice_free (SmsDeletePartsContext, ctx); +} + +static gboolean +sms_delete_finish (MMBaseSms *self, + GAsyncResult *res, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (res), error); +} + +static void delete_next_part (GTask *task); + +static void +delete_part_ready (MMBaseModem *modem, + GAsyncResult *res, + GTask *task) +{ + MMSmsAt *self; + SmsDeletePartsContext *ctx; + g_autoptr(GError) error = NULL; + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + mm_base_modem_at_command_finish (modem, res, &error); + if (error) { + ctx->n_failed++; + mm_obj_dbg (self, "couldn't delete SMS part with index %u: %s", + mm_sms_part_get_index ((MMSmsPart *)ctx->current->data), + error->message); + } + + /* We reset the index, as there is no longer that part */ + mm_sms_part_set_index ((MMSmsPart *)ctx->current->data, SMS_PART_INVALID_INDEX); + + ctx->current = g_list_next (ctx->current); + delete_next_part (task); +} + +static void +delete_next_part (GTask *task) +{ + SmsDeletePartsContext *ctx; + g_autofree gchar *cmd = NULL; + + ctx = g_task_get_task_data (task); + + /* Skip non-stored parts */ + while (ctx->current && (mm_sms_part_get_index ((MMSmsPart *)ctx->current->data) == SMS_PART_INVALID_INDEX)) + ctx->current = g_list_next (ctx->current); + + /* If all removed, we're done */ + if (!ctx->current) { + if (ctx->n_failed > 0) + g_task_return_new_error (task, + MM_CORE_ERROR, + MM_CORE_ERROR_FAILED, + "Couldn't delete %u parts from this SMS", + ctx->n_failed); + else + g_task_return_boolean (task, TRUE); + g_object_unref (task); + return; + } + + cmd = g_strdup_printf ("+CMGD=%d", mm_sms_part_get_index ((MMSmsPart *)ctx->current->data)); + mm_base_modem_at_command (ctx->modem, + cmd, + 10, + FALSE, + (GAsyncReadyCallback)delete_part_ready, + task); +} + +static void +delete_lock_sms_storages_ready (MMIfaceModemMessaging *messaging, + GAsyncResult *res, + GTask *task) +{ + MMSmsAt *self; + SmsDeletePartsContext *ctx; + GError *error = NULL; + + if (!mm_iface_modem_messaging_lock_storages_finish (messaging, res, &error)) { + g_task_return_error (task, error); + g_object_unref (task); + return; + } + + self = g_task_get_source_object (task); + ctx = g_task_get_task_data (task); + + /* We are now locked. Whatever result we have here, we need to make sure + * we unlock the storages before finishing. */ + ctx->need_unlock = TRUE; + + /* Go on deleting parts */ + ctx->current = mm_base_sms_get_parts (MM_BASE_SMS (self)); + delete_next_part (task); +} + +static void +sms_delete (MMBaseSms *sms, + GAsyncReadyCallback callback, + gpointer user_data) +{ + MMSmsAt *self = MM_SMS_AT (sms); + SmsDeletePartsContext *ctx; + GTask *task; + + ctx = g_slice_new0 (SmsDeletePartsContext); + ctx->modem = g_object_ref (self->priv->modem); + + task = g_task_new (self, NULL, callback, user_data); + g_task_set_task_data (task, ctx, (GDestroyNotify)sms_delete_parts_context_free); + + if (mm_base_sms_get_storage (MM_BASE_SMS (self)) == MM_SMS_STORAGE_UNKNOWN) { + mm_obj_dbg (self, "not removing parts from non-stored SMS"); + g_task_return_boolean (task, TRUE); + g_object_unref (task); + return; + } + + /* Select specific storage to delete from */ + mm_iface_modem_messaging_lock_storages ( + MM_IFACE_MODEM_MESSAGING (self->priv->modem), + mm_base_sms_get_storage (MM_BASE_SMS (self)), + MM_SMS_STORAGE_UNKNOWN, /* none required for mem2 */ + (GAsyncReadyCallback)delete_lock_sms_storages_ready, + task); +} + +/*****************************************************************************/ + +MMBaseSms * +mm_sms_at_new (MMBaseModem *modem, gboolean is_3gpp) +{ + MMBaseSms *sms; + + sms = MM_BASE_SMS (g_object_new (MM_TYPE_SMS_AT, + MM_BASE_SMS_MODEM, modem, + MM_BASE_SMS_IS_3GPP, is_3gpp, + NULL)); + MM_SMS_AT (sms)->priv->modem = g_object_ref (modem); + return sms; +} + +static void +mm_sms_at_init (MMSmsAt *self) +{ + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_SMS_AT, MMSmsAtPrivate); +} + +static void +dispose (GObject *object) +{ + MMSmsAt *self = MM_SMS_AT (object); + + g_clear_object (&self->priv->modem); + + G_OBJECT_CLASS (mm_sms_at_parent_class)->dispose (object); +} + +static void +mm_sms_at_class_init (MMSmsAtClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + MMBaseSmsClass *base_sms_class = MM_BASE_SMS_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (MMSmsAtPrivate)); + + object_class->dispose = dispose; + + base_sms_class->store = sms_store; + base_sms_class->store_finish = sms_store_finish; + base_sms_class->send = sms_send; + base_sms_class->send_finish = sms_send_finish; + base_sms_class->delete = sms_delete; + base_sms_class->delete_finish = sms_delete_finish; +} -- cgit v1.2.3-70-g09d2 From 9c8ec57c24ed8eeafaa3c84f5a458c9c41d22ae5 Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Sat, 19 Apr 2025 10:57:54 -0500 Subject: base-sms: pass SMS default storage at creation time and update as needed Instead of getting it from the MMIfaceModemMessaging when the SMS is stored. This flattens dependencies between MMBaseSms and MMIfaceModemMessaging. Signed-off-by: Dan Williams --- src/mm-base-sms.c | 22 +++++++++++++++++++--- src/mm-base-sms.h | 1 + src/mm-broadband-modem-mbim.c | 6 +++++- src/mm-broadband-modem-qmi.c | 5 ++++- src/mm-broadband-modem.c | 6 +++++- src/mm-iface-modem-messaging.c | 22 +++++++++++++++++++++- src/mm-iface-modem-messaging.h | 2 ++ src/mm-sms-at.c | 5 ++++- src/mm-sms-at.h | 5 +++-- src/mm-sms-list.c | 15 +++++++++++++++ src/mm-sms-list.h | 3 +++ src/mm-sms-mbim.c | 5 ++++- src/mm-sms-mbim.h | 5 +++-- src/mm-sms-qmi.c | 5 ++++- src/mm-sms-qmi.h | 5 +++-- 15 files changed, 96 insertions(+), 16 deletions(-) (limited to 'src/mm-sms-at.c') diff --git a/src/mm-base-sms.c b/src/mm-base-sms.c index daf7fb67..07081aa3 100644 --- a/src/mm-base-sms.c +++ b/src/mm-base-sms.c @@ -55,6 +55,7 @@ enum { PROP_MAX_PARTS, PROP_MULTIPART_REFERENCE, PROP_IS_3GPP, + PROP_DEFAULT_STORAGE, PROP_LAST }; @@ -93,6 +94,8 @@ struct _MMBaseSmsPrivate { /* TRUE for 3GPP SMS; FALSE for CDMA */ gboolean is_3gpp; + + MMSmsStorage default_storage; }; /*****************************************************************************/ @@ -486,9 +489,7 @@ handle_store (MMBaseSms *self, if (ctx->storage == MM_SMS_STORAGE_UNKNOWN) { /* We'll set now the proper storage, taken from the default mem2 one */ - g_object_get (self->priv->modem, - MM_IFACE_MODEM_MESSAGING_SMS_DEFAULT_STORAGE, &ctx->storage, - NULL); + ctx->storage = self->priv->default_storage; g_assert (ctx->storage != MM_SMS_STORAGE_UNKNOWN); } @@ -1265,6 +1266,9 @@ set_property (GObject *object, case PROP_IS_3GPP: self->priv->is_3gpp = g_value_get_boolean (value); break; + case PROP_DEFAULT_STORAGE: + self->priv->default_storage = g_value_get_enum (value); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1304,6 +1308,9 @@ get_property (GObject *object, case PROP_IS_3GPP: g_value_set_boolean (value, self->priv->is_3gpp); break; + case PROP_DEFAULT_STORAGE: + g_value_set_enum (value, self->priv->default_storage); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1440,4 +1447,13 @@ mm_base_sms_class_init (MMBaseSmsClass *klass) FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_IS_3GPP, properties[PROP_IS_3GPP]); + + properties[PROP_DEFAULT_STORAGE] = + g_param_spec_enum (MM_BASE_SMS_DEFAULT_STORAGE, + "Default storage", + "Default SMS storage", + MM_TYPE_SMS_STORAGE, + MM_SMS_STORAGE_UNKNOWN, + G_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_DEFAULT_STORAGE, properties[PROP_DEFAULT_STORAGE]); } diff --git a/src/mm-base-sms.h b/src/mm-base-sms.h index 22d25ebb..14902167 100644 --- a/src/mm-base-sms.h +++ b/src/mm-base-sms.h @@ -53,6 +53,7 @@ typedef struct _MMBaseSmsPrivate MMBaseSmsPrivate; #define MM_BASE_SMS_MAX_PARTS "sms-max-parts" #define MM_BASE_SMS_MULTIPART_REFERENCE "sms-multipart-reference" #define MM_BASE_SMS_IS_3GPP "sms-is-3gpp" +#define MM_BASE_SMS_DEFAULT_STORAGE "sms-default-storage" struct _MMBaseSms { MmGdbusSmsSkeleton parent; diff --git a/src/mm-broadband-modem-mbim.c b/src/mm-broadband-modem-mbim.c index 91a18cb2..5d7e37be 100644 --- a/src/mm-broadband-modem-mbim.c +++ b/src/mm-broadband-modem-mbim.c @@ -9242,8 +9242,12 @@ enable_unsolicited_events_messaging (MMIfaceModemMessaging *_self, static MMBaseSms * messaging_create_sms (MMBroadbandModem *self) { + MMSmsStorage default_storage; + + default_storage = mm_iface_modem_messaging_get_default_storage (MM_IFACE_MODEM_MESSAGING (self)); return mm_sms_mbim_new (MM_BASE_MODEM (self), - mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self))); + mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self)), + default_storage); } /*****************************************************************************/ diff --git a/src/mm-broadband-modem-qmi.c b/src/mm-broadband-modem-qmi.c index 6caccc21..4f153009 100644 --- a/src/mm-broadband-modem-qmi.c +++ b/src/mm-broadband-modem-qmi.c @@ -8881,14 +8881,17 @@ static MMBaseSms * messaging_create_sms (MMBroadbandModem *_self) { MMBroadbandModemQmi *self = MM_BROADBAND_MODEM_QMI (_self); + MMSmsStorage default_storage; /* Handle AT URC only fallback */ if (self->priv->messaging_fallback_at_only) { return MM_BROADBAND_MODEM_CLASS (mm_broadband_modem_qmi_parent_class)->create_sms (_self); } + default_storage = mm_iface_modem_messaging_get_default_storage (MM_IFACE_MODEM_MESSAGING (self)); return mm_sms_qmi_new (MM_BASE_MODEM (self), - mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self))); + mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self)), + default_storage); } diff --git a/src/mm-broadband-modem.c b/src/mm-broadband-modem.c index c29c9190..f164be01 100644 --- a/src/mm-broadband-modem.c +++ b/src/mm-broadband-modem.c @@ -8259,8 +8259,12 @@ mm_broadband_modem_create_sms (MMBroadbandModem *self) static MMBaseSms * modem_messaging_create_sms (MMBroadbandModem *self) { + MMSmsStorage default_storage; + + default_storage = mm_iface_modem_messaging_get_default_storage (MM_IFACE_MODEM_MESSAGING (self)); return mm_sms_at_new (MM_BASE_MODEM (self), - mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self))); + mm_iface_modem_is_3gpp (MM_IFACE_MODEM (self)), + default_storage); } /*****************************************************************************/ diff --git a/src/mm-iface-modem-messaging.c b/src/mm-iface-modem-messaging.c index 51c8b24e..941e58e0 100644 --- a/src/mm-iface-modem-messaging.c +++ b/src/mm-iface-modem-messaging.c @@ -433,7 +433,8 @@ handle_set_default_storage_ready (MMIfaceModemMessaging *self, GAsyncResult *res, HandleSetDefaultStorageContext *ctx) { - GError *error = NULL; + GError *error = NULL; + g_autoptr(MMSmsList) list = NULL; if (!MM_IFACE_MODEM_MESSAGING_GET_IFACE (self)->set_default_storage_finish (self, res, &error)) { mm_obj_warn (self, "could not set default storage: %s", error->message); @@ -446,6 +447,13 @@ handle_set_default_storage_ready (MMIfaceModemMessaging *self, MM_IFACE_MODEM_MESSAGING_SMS_DEFAULT_STORAGE, ctx->storage, NULL); + /* Update default storage in all SMSs too */ + g_object_get (self, + MM_IFACE_MODEM_MESSAGING_SMS_LIST, &list, + NULL); + if (list) + mm_sms_list_set_default_storage (list, ctx->storage); + mm_obj_info (self, "set the default storage successfully"); mm_gdbus_modem_messaging_complete_set_default_storage (ctx->skeleton, ctx->invocation); handle_set_default_storage_context_free (ctx); @@ -598,6 +606,18 @@ mm_iface_modem_messaging_is_storage_supported_for_receiving (MMIfaceModemMessagi error); } +MMSmsStorage +mm_iface_modem_messaging_get_default_storage (MMIfaceModemMessaging *self) +{ + MMSmsStorage storage = MM_SMS_STORAGE_UNKNOWN; + + g_object_get (self, + MM_IFACE_MODEM_MESSAGING_SMS_DEFAULT_STORAGE, &storage, + NULL); + g_assert (storage != MM_SMS_STORAGE_UNKNOWN); + return storage; +} + /*****************************************************************************/ static void diff --git a/src/mm-iface-modem-messaging.h b/src/mm-iface-modem-messaging.h index f62324c9..d7f29b6d 100644 --- a/src/mm-iface-modem-messaging.h +++ b/src/mm-iface-modem-messaging.h @@ -193,6 +193,8 @@ gboolean mm_iface_modem_messaging_is_storage_supported_for_receiving (MMIfaceMod MMSmsStorage storage, GError **error); +MMSmsStorage mm_iface_modem_messaging_get_default_storage (MMIfaceModemMessaging *self); + /* SMS creation */ MMBaseSms *mm_iface_modem_messaging_create_sms (MMIfaceModemMessaging *self); diff --git a/src/mm-sms-at.c b/src/mm-sms-at.c index 3fc7c155..b79a95ab 100644 --- a/src/mm-sms-at.c +++ b/src/mm-sms-at.c @@ -788,13 +788,16 @@ sms_delete (MMBaseSms *sms, /*****************************************************************************/ MMBaseSms * -mm_sms_at_new (MMBaseModem *modem, gboolean is_3gpp) +mm_sms_at_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage) { MMBaseSms *sms; sms = MM_BASE_SMS (g_object_new (MM_TYPE_SMS_AT, MM_BASE_SMS_MODEM, modem, MM_BASE_SMS_IS_3GPP, is_3gpp, + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, NULL)); MM_SMS_AT (sms)->priv->modem = g_object_ref (modem); return sms; diff --git a/src/mm-sms-at.h b/src/mm-sms-at.h index 26e2dae4..551d50eb 100644 --- a/src/mm-sms-at.h +++ b/src/mm-sms-at.h @@ -53,7 +53,8 @@ struct _MMSmsAtClass { GType mm_sms_at_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMSmsAt, g_object_unref) -MMBaseSms *mm_sms_at_new (MMBaseModem *modem, - gboolean is_3gpp); +MMBaseSms *mm_sms_at_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage); #endif /* MM_SMS_AT_H */ diff --git a/src/mm-sms-list.c b/src/mm-sms-list.c index 21515aa5..69c62153 100644 --- a/src/mm-sms-list.c +++ b/src/mm-sms-list.c @@ -394,6 +394,21 @@ mm_sms_list_take_part (MMSmsList *self, /*****************************************************************************/ +void +mm_sms_list_set_default_storage (MMSmsList *self, + MMSmsStorage default_storage) +{ + GList *l; + + for (l = self->priv->list; l; l = g_list_next (l)) { + g_object_set (MM_BASE_SMS (l->data), + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, + NULL); + } +} + +/*****************************************************************************/ + static gchar * log_object_build_id (MMLogObject *_self) { diff --git a/src/mm-sms-list.h b/src/mm-sms-list.h index e8503a22..53fa63f0 100644 --- a/src/mm-sms-list.h +++ b/src/mm-sms-list.h @@ -89,4 +89,7 @@ gboolean mm_sms_list_has_local_multipart_reference (MMSmsList *self, const gchar *number, guint8 reference); +void mm_sms_list_set_default_storage (MMSmsList *self, + MMSmsStorage default_storage); + #endif /* MM_SMS_LIST_H */ diff --git a/src/mm-sms-mbim.c b/src/mm-sms-mbim.c index 1cb442d6..7b3edb84 100644 --- a/src/mm-sms-mbim.c +++ b/src/mm-sms-mbim.c @@ -332,12 +332,15 @@ sms_delete (MMBaseSms *self, /*****************************************************************************/ MMBaseSms * -mm_sms_mbim_new (MMBaseModem *modem, gboolean is_3gpp) +mm_sms_mbim_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage) { return MM_BASE_SMS (g_object_new (MM_TYPE_SMS_MBIM, MM_BASE_SMS_MODEM, modem, MM_BIND_TO, G_OBJECT (modem), MM_BASE_SMS_IS_3GPP, is_3gpp, + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, NULL)); } diff --git a/src/mm-sms-mbim.h b/src/mm-sms-mbim.h index 070ff677..7877c3f1 100644 --- a/src/mm-sms-mbim.h +++ b/src/mm-sms-mbim.h @@ -45,7 +45,8 @@ struct _MMSmsMbimClass { GType mm_sms_mbim_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMSmsMbim, g_object_unref) -MMBaseSms *mm_sms_mbim_new (MMBaseModem *modem, - gboolean is_3gpp); +MMBaseSms *mm_sms_mbim_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage); #endif /* MM_SMS_MBIM_H */ diff --git a/src/mm-sms-qmi.c b/src/mm-sms-qmi.c index aa5101ee..ebd8f845 100644 --- a/src/mm-sms-qmi.c +++ b/src/mm-sms-qmi.c @@ -786,12 +786,15 @@ sms_delete (MMBaseSms *self, /*****************************************************************************/ MMBaseSms * -mm_sms_qmi_new (MMBaseModem *modem, gboolean is_3gpp) +mm_sms_qmi_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage) { return MM_BASE_SMS (g_object_new (MM_TYPE_SMS_QMI, MM_BASE_SMS_MODEM, modem, MM_BIND_TO, G_OBJECT (modem), MM_BASE_SMS_IS_3GPP, is_3gpp, + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, NULL)); } diff --git a/src/mm-sms-qmi.h b/src/mm-sms-qmi.h index 250e406e..1dda2a95 100644 --- a/src/mm-sms-qmi.h +++ b/src/mm-sms-qmi.h @@ -47,7 +47,8 @@ struct _MMSmsQmiClass { GType mm_sms_qmi_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMSmsQmi, g_object_unref) -MMBaseSms *mm_sms_qmi_new (MMBaseModem *modem, - gboolean is_3gpp); +MMBaseSms *mm_sms_qmi_new (MMBaseModem *modem, + gboolean is_3gpp, + MMSmsStorage default_storage); #endif /* MM_SMS_QMI_H */ -- cgit v1.2.3-70-g09d2 From 03027b5ec2821b11c64966b2bf79d24ef42d5777 Mon Sep 17 00:00:00 2001 From: Dan Williams Date: Sat, 19 Apr 2025 19:43:08 -0500 Subject: base-sms: remove MODEM property No longer depend on MMBaseModem since everything that specifically uses it is now removed. Signed-off-by: Dan Williams --- src/mm-base-sms.c | 34 +++-------------- src/mm-base-sms.h | 6 +-- src/mm-iface-modem-messaging.c | 2 +- src/mm-sms-at.c | 3 +- src/mm-sms-list.c | 2 - src/mm-sms-mbim.c | 60 +++++++++++++++++++----------- src/mm-sms-mbim.h | 2 + src/mm-sms-qmi.c | 84 +++++++++++++++++++++--------------------- src/mm-sms-qmi.h | 2 + 9 files changed, 95 insertions(+), 100 deletions(-) (limited to 'src/mm-sms-at.c') diff --git a/src/mm-base-sms.c b/src/mm-base-sms.c index 410ccc74..4f67d5ea 100644 --- a/src/mm-base-sms.c +++ b/src/mm-base-sms.c @@ -27,10 +27,7 @@ #include #include "mm-base-sms.h" -#include "mm-broadband-modem.h" #include "mm-auth-provider.h" -#include "mm-iface-modem.h" -#include "mm-iface-modem-messaging.h" #include "mm-sms-part-3gpp.h" #include "mm-log-object.h" #include "mm-modem-helpers.h" @@ -50,7 +47,6 @@ enum { PROP_PATH, PROP_CONNECTION, PROP_BIND_TO, - PROP_MODEM, PROP_IS_MULTIPART, PROP_MAX_PARTS, PROP_MULTIPART_REFERENCE, @@ -75,6 +71,12 @@ struct _MMBaseSmsPrivate { /* The connection to the system bus */ GDBusConnection *connection; guint dbus_id; + /* Object to which our connection property should be bound */ + GObject *connection_parent; + /* GObject property name of the parent's connection property to + * which this SMS"s connection should be bound. + */ + gchar *connection_parent_property_name; /* The authorization provider */ MMAuthProvider *authp; @@ -83,8 +85,6 @@ struct _MMBaseSmsPrivate { /* The object this SMS is bound to */ GObject *bind_to; - /* The modem which owns this SMS */ - MMBaseModem *modem; /* The path where the SMS object is exported */ gchar *path; @@ -1094,13 +1094,11 @@ mm_base_sms_multipart_take_part (MMBaseSms *self, gboolean mm_base_sms_singlepart_init (MMBaseSms *self, - MMBaseModem *modem, MMSmsState state, MMSmsStorage storage, MMSmsPart *part, GError **error) { - g_assert (MM_IS_IFACE_MODEM_MESSAGING (modem)); g_assert (self->priv->initialized == FALSE); g_object_set (self, @@ -1129,7 +1127,6 @@ mm_base_sms_singlepart_init (MMBaseSms *self, gboolean mm_base_sms_multipart_init (MMBaseSms *self, - MMBaseModem *modem, MMSmsState state, MMSmsStorage storage, guint reference, @@ -1137,7 +1134,6 @@ mm_base_sms_multipart_init (MMBaseSms *self, MMSmsPart *first_part, GError **error) { - g_assert (MM_IS_IFACE_MODEM_MESSAGING (modem)); g_assert (self->priv->initialized == FALSE); /* If this is the first part of a RECEIVED SMS, we overwrite the state @@ -1173,14 +1169,12 @@ mm_base_sms_multipart_init (MMBaseSms *self, gboolean mm_base_sms_init_from_properties (MMBaseSms *self, - MMBaseModem *modem, MMSmsProperties *props, GError **error) { const gchar *text; GByteArray *data; - g_assert (MM_IS_IFACE_MODEM_MESSAGING (modem)); g_assert (self->priv->initialized == FALSE); text = mm_sms_properties_get_text (props); @@ -1301,10 +1295,6 @@ set_property (GObject *object, self->priv->bind_to = g_value_dup_object (value); mm_bind_to (MM_BIND (self), MM_BASE_SMS_CONNECTION, self->priv->bind_to); break; - case PROP_MODEM: - g_clear_object (&self->priv->modem); - self->priv->modem = g_value_dup_object (value); - break; case PROP_IS_MULTIPART: self->priv->is_multipart = g_value_get_boolean (value); break; @@ -1349,9 +1339,6 @@ 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); - break; case PROP_IS_MULTIPART: g_value_set_boolean (value, self->priv->is_multipart); break; @@ -1417,7 +1404,6 @@ dispose (GObject *object) g_clear_object (&self->priv->connection); } - g_clear_object (&self->priv->modem); g_clear_object (&self->priv->bind_to); g_cancellable_cancel (self->priv->authp_cancellable); g_clear_object (&self->priv->authp_cancellable); @@ -1468,14 +1454,6 @@ mm_base_sms_class_init (MMBaseSmsClass *klass) g_object_class_override_property (object_class, PROP_BIND_TO, MM_BIND_TO); - properties[PROP_MODEM] = - g_param_spec_object (MM_BASE_SMS_MODEM, - "Modem", - "The Modem which owns this SMS", - MM_TYPE_BASE_MODEM, - G_PARAM_READWRITE); - g_object_class_install_property (object_class, PROP_MODEM, properties[PROP_MODEM]); - properties[PROP_IS_MULTIPART] = g_param_spec_boolean (MM_BASE_SMS_IS_MULTIPART, "Is multipart", diff --git a/src/mm-base-sms.h b/src/mm-base-sms.h index f87a6640..ecd7ad2a 100644 --- a/src/mm-base-sms.h +++ b/src/mm-base-sms.h @@ -25,7 +25,6 @@ #include #include "mm-sms-part.h" -#include "mm-base-modem.h" /*****************************************************************************/ @@ -49,13 +48,13 @@ typedef struct _MMBaseSmsPrivate MMBaseSmsPrivate; /* Properties */ #define MM_BASE_SMS_PATH "sms-path" #define MM_BASE_SMS_CONNECTION "sms-connection" -#define MM_BASE_SMS_MODEM "sms-modem" #define MM_BASE_SMS_IS_MULTIPART "sms-is-multipart" #define MM_BASE_SMS_MAX_PARTS "sms-max-parts" #define MM_BASE_SMS_MULTIPART_REFERENCE "sms-multipart-reference" #define MM_BASE_SMS_IS_3GPP "sms-is-3gpp" #define MM_BASE_SMS_DEFAULT_STORAGE "sms-default-storage" #define MM_BASE_SMS_SUPPORTED_STORAGES "sms-supported-storages" +#define MM_BASE_SMS_CONNECTION_PARENT_PROPERTY_NAME "sms-connection-parent-property-name" /* Signals */ #define MM_BASE_SMS_SET_LOCAL_MULTIPART_REFERENCE "sms-set-local-multipart-reference" @@ -102,17 +101,14 @@ GType mm_base_sms_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (MMBaseSms, g_object_unref) gboolean mm_base_sms_init_from_properties (MMBaseSms *self, - MMBaseModem *modem, MMSmsProperties *properties, GError **error); gboolean mm_base_sms_singlepart_init (MMBaseSms *self, - MMBaseModem *modem, MMSmsState state, MMSmsStorage storage, MMSmsPart *part, GError **error); gboolean mm_base_sms_multipart_init (MMBaseSms *self, - MMBaseModem *modem, MMSmsState state, MMSmsStorage storage, guint reference, diff --git a/src/mm-iface-modem-messaging.c b/src/mm-iface-modem-messaging.c index b6b63e49..d349de35 100644 --- a/src/mm-iface-modem-messaging.c +++ b/src/mm-iface-modem-messaging.c @@ -283,7 +283,7 @@ handle_create_auth_ready (MMIfaceAuth *auth, } sms = mm_broadband_modem_create_sms (MM_BROADBAND_MODEM (self)); - if (!mm_base_sms_init_from_properties (sms, MM_BASE_MODEM (self), properties, &error)) { + if (!mm_base_sms_init_from_properties (sms, properties, &error)) { mm_dbus_method_invocation_take_error (ctx->invocation, error); handle_create_context_free (ctx); return; diff --git a/src/mm-sms-at.c b/src/mm-sms-at.c index b79a95ab..4f817e65 100644 --- a/src/mm-sms-at.c +++ b/src/mm-sms-at.c @@ -32,6 +32,7 @@ #include "mm-sms-part-3gpp.h" #include "mm-base-modem-at.h" #include "mm-log-object.h" +#include "mm-bind.h" G_DEFINE_TYPE (MMSmsAt, mm_sms_at, MM_TYPE_BASE_SMS) @@ -795,7 +796,7 @@ mm_sms_at_new (MMBaseModem *modem, MMBaseSms *sms; sms = MM_BASE_SMS (g_object_new (MM_TYPE_SMS_AT, - MM_BASE_SMS_MODEM, modem, + MM_BIND_TO, G_OBJECT (modem), MM_BASE_SMS_IS_3GPP, is_3gpp, MM_BASE_SMS_DEFAULT_STORAGE, default_storage, NULL)); diff --git a/src/mm-sms-list.c b/src/mm-sms-list.c index 99f35da1..b4b8619b 100644 --- a/src/mm-sms-list.c +++ b/src/mm-sms-list.c @@ -315,7 +315,6 @@ take_singlepart (MMSmsList *self, GError **error) { if (!mm_base_sms_singlepart_init (sms, - self->priv->modem, state, storage, part, @@ -349,7 +348,6 @@ take_multipart (MMSmsList *self, /* Create new Multipart */ if (!mm_base_sms_multipart_init (sms, - self->priv->modem, state, storage, concat_reference, diff --git a/src/mm-sms-mbim.c b/src/mm-sms-mbim.c index 7b3edb84..ffb6b466 100644 --- a/src/mm-sms-mbim.c +++ b/src/mm-sms-mbim.c @@ -35,25 +35,22 @@ G_DEFINE_TYPE (MMSmsMbim, mm_sms_mbim, MM_TYPE_BASE_SMS) +struct _MMSmsMbimPrivate { + MMBaseModem *modem; +}; + /*****************************************************************************/ static gboolean -peek_device (gpointer self, - MbimDevice **o_device, - GAsyncReadyCallback callback, - gpointer user_data) +peek_device (MMSmsMbim *self, + MbimDevice **o_device, + GAsyncReadyCallback callback, + gpointer user_data) { - MMBaseModem *modem = NULL; - - g_object_get (G_OBJECT (self), - MM_BASE_SMS_MODEM, &modem, - NULL); - g_assert (MM_IS_BASE_MODEM (modem)); - if (o_device) { MMPortMbim *port; - port = mm_broadband_modem_mbim_peek_port_mbim (MM_BROADBAND_MODEM_MBIM (modem)); + port = mm_broadband_modem_mbim_peek_port_mbim (MM_BROADBAND_MODEM_MBIM (self->priv->modem)); if (!port) { g_task_report_new_error (self, callback, @@ -62,14 +59,12 @@ peek_device (gpointer self, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Couldn't peek MBIM port"); - g_object_unref (modem); return FALSE; } *o_device = mm_port_mbim_peek_device (port); } - g_object_unref (modem); return TRUE; } @@ -191,7 +186,7 @@ sms_send (MMBaseSms *self, MbimDevice *device; GTask *task; - if (!peek_device (self, &device, callback, user_data)) + if (!peek_device (MM_SMS_MBIM (self), &device, callback, user_data)) return; /* Setup the context */ @@ -315,7 +310,7 @@ sms_delete (MMBaseSms *self, MbimDevice *device; GTask *task; - if (!peek_device (self, &device, callback, user_data)) + if (!peek_device (MM_SMS_MBIM (self), &device, callback, user_data)) return; ctx = g_slice_new0 (SmsDeletePartsContext); @@ -336,24 +331,45 @@ mm_sms_mbim_new (MMBaseModem *modem, gboolean is_3gpp, MMSmsStorage default_storage) { - return MM_BASE_SMS (g_object_new (MM_TYPE_SMS_MBIM, - MM_BASE_SMS_MODEM, modem, - MM_BIND_TO, G_OBJECT (modem), - MM_BASE_SMS_IS_3GPP, is_3gpp, - MM_BASE_SMS_DEFAULT_STORAGE, default_storage, - NULL)); + MMBaseSms *sms; + + g_return_val_if_fail (MM_IS_BROADBAND_MODEM_MBIM (modem), NULL); + + sms = MM_BASE_SMS (g_object_new (MM_TYPE_SMS_MBIM, + MM_BIND_TO, G_OBJECT (modem), + MM_BASE_SMS_IS_3GPP, is_3gpp, + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, + NULL)); + MM_SMS_MBIM (sms)->priv->modem = g_object_ref (modem); + return sms; } static void mm_sms_mbim_init (MMSmsMbim *self) { + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_SMS_MBIM, MMSmsMbimPrivate); +} + +static void +dispose (GObject *object) +{ + MMSmsMbim *self = MM_SMS_MBIM (object); + + g_clear_object (&self->priv->modem); + + G_OBJECT_CLASS (mm_sms_mbim_parent_class)->dispose (object); } static void mm_sms_mbim_class_init (MMSmsMbimClass *klass) { + GObjectClass *object_class = G_OBJECT_CLASS (klass); MMBaseSmsClass *base_sms_class = MM_BASE_SMS_CLASS (klass); + g_type_class_add_private (object_class, sizeof (MMSmsMbimPrivate)); + + object_class->dispose = dispose; + base_sms_class->store = NULL; base_sms_class->store_finish = NULL; base_sms_class->send = sms_send; diff --git a/src/mm-sms-mbim.h b/src/mm-sms-mbim.h index 7877c3f1..b045b99c 100644 --- a/src/mm-sms-mbim.h +++ b/src/mm-sms-mbim.h @@ -33,9 +33,11 @@ typedef struct _MMSmsMbim MMSmsMbim; typedef struct _MMSmsMbimClass MMSmsMbimClass; +typedef struct _MMSmsMbimPrivate MMSmsMbimPrivate; struct _MMSmsMbim { MMBaseSms parent; + MMSmsMbimPrivate *priv; }; struct _MMSmsMbimClass { diff --git a/src/mm-sms-qmi.c b/src/mm-sms-qmi.c index ebd8f845..a131ccc9 100644 --- a/src/mm-sms-qmi.c +++ b/src/mm-sms-qmi.c @@ -37,6 +37,10 @@ G_DEFINE_TYPE (MMSmsQmi, mm_sms_qmi, MM_TYPE_BASE_SMS) +struct _MMSmsQmiPrivate { + MMBaseModem *modem; +}; + /*****************************************************************************/ static gboolean @@ -46,18 +50,10 @@ ensure_qmi_client (MMSmsQmi *self, GAsyncReadyCallback callback, gpointer user_data) { - MMBaseModem *modem = NULL; QmiClient *client; MMPortQmi *port; - g_object_get (self, - MM_BASE_SMS_MODEM, &modem, - NULL); - g_assert (MM_IS_BASE_MODEM (modem)); - - port = mm_broadband_modem_qmi_peek_port_qmi (MM_BROADBAND_MODEM_QMI (modem)); - g_object_unref (modem); - + port = mm_broadband_modem_qmi_peek_port_qmi (MM_BROADBAND_MODEM_QMI (self->priv->modem)); if (!port) { g_task_report_new_error (self, callback, @@ -119,7 +115,6 @@ check_sms_type_support (MMSmsQmi *self, /* Store the SMS */ typedef struct { - MMBaseModem *modem; QmiClientWms *client; MMSmsStorage storage; GList *current; @@ -129,7 +124,6 @@ static void sms_store_context_free (SmsStoreContext *ctx) { g_object_unref (ctx->client); - g_object_unref (ctx->modem); g_slice_free (SmsStoreContext, ctx); } @@ -260,11 +254,12 @@ sms_store_next_part (GTask *task) } static void -sms_store (MMBaseSms *self, +sms_store (MMBaseSms *_self, MMSmsStorage storage, GAsyncReadyCallback callback, gpointer user_data) { + MMSmsQmi *self = MM_SMS_QMI (_self); SmsStoreContext *ctx; QmiClient *client = NULL; GError *error = NULL; @@ -280,17 +275,13 @@ sms_store (MMBaseSms *self, ctx = g_slice_new0 (SmsStoreContext); ctx->client = QMI_CLIENT_WMS (g_object_ref (client)); ctx->storage = storage; - g_object_get (self, - MM_BASE_SMS_MODEM, &ctx->modem, - NULL); - - ctx->current = mm_base_sms_get_parts (self); + ctx->current = mm_base_sms_get_parts (_self); task = g_task_new (self, NULL, callback, user_data); g_task_set_task_data (task, ctx, (GDestroyNotify)sms_store_context_free); /* Check whether we support the given SMS type */ - if (!check_sms_type_support (MM_SMS_QMI (self), ctx->modem, (MMSmsPart *)ctx->current->data, &error)) { + if (!check_sms_type_support (MM_SMS_QMI (self), self->priv->modem, (MMSmsPart *)ctx->current->data, &error)) { g_task_return_error (task, error); g_object_unref (task); return; @@ -304,7 +295,6 @@ sms_store (MMBaseSms *self, /* Send the SMS */ typedef struct { - MMBaseModem *modem; QmiClientWms *client; gboolean from_storage; GList *current; @@ -314,7 +304,6 @@ static void sms_send_context_free (SmsSendContext *ctx) { g_object_unref (ctx->client); - g_object_unref (ctx->modem); g_slice_free (SmsSendContext, ctx); } @@ -595,10 +584,11 @@ sms_send_next_part (GTask *task) } static void -sms_send (MMBaseSms *self, - GAsyncReadyCallback callback, - gpointer user_data) +sms_send (MMBaseSms *_self, + GAsyncReadyCallback callback, + gpointer user_data) { + MMSmsQmi *self = MM_SMS_QMI (_self); SmsSendContext *ctx; QmiClient *client = NULL; GError *error = NULL; @@ -613,20 +603,16 @@ sms_send (MMBaseSms *self, /* Setup the context */ ctx = g_slice_new0 (SmsSendContext); ctx->client = QMI_CLIENT_WMS (g_object_ref (client)); - g_object_get (self, - MM_BASE_SMS_MODEM, &ctx->modem, - NULL); - /* If the SMS is STORED, try to send from storage */ - ctx->from_storage = (mm_base_sms_get_storage (self) != MM_SMS_STORAGE_UNKNOWN); + ctx->from_storage = (mm_base_sms_get_storage (_self) != MM_SMS_STORAGE_UNKNOWN); - ctx->current = mm_base_sms_get_parts (self); + ctx->current = mm_base_sms_get_parts (_self); task = g_task_new (self, NULL, callback, user_data); g_task_set_task_data (task, ctx, (GDestroyNotify)sms_send_context_free); /* Check whether we support the given SMS type */ - if (!check_sms_type_support (MM_SMS_QMI (self), ctx->modem, (MMSmsPart *)ctx->current->data, &error)) { + if (!check_sms_type_support (MM_SMS_QMI (self), self->priv->modem, (MMSmsPart *)ctx->current->data, &error)) { g_task_return_error (task, error); g_object_unref (task); return; @@ -638,7 +624,6 @@ sms_send (MMBaseSms *self, /*****************************************************************************/ typedef struct { - MMBaseModem *modem; QmiClientWms *client; GList *current; guint n_failed; @@ -648,7 +633,6 @@ static void sms_delete_parts_context_free (SmsDeletePartsContext *ctx) { g_object_unref (ctx->client); - g_object_unref (ctx->modem); g_slice_free (SmsDeletePartsContext, ctx); } @@ -771,9 +755,6 @@ sms_delete (MMBaseSms *self, ctx = g_slice_new0 (SmsDeletePartsContext); ctx->client = QMI_CLIENT_WMS (g_object_ref (client)); - g_object_get (self, - MM_BASE_SMS_MODEM, &ctx->modem, - NULL); task = g_task_new (self, NULL, callback, user_data); g_task_set_task_data (task, ctx, (GDestroyNotify)sms_delete_parts_context_free); @@ -790,24 +771,45 @@ mm_sms_qmi_new (MMBaseModem *modem, gboolean is_3gpp, MMSmsStorage default_storage) { - return MM_BASE_SMS (g_object_new (MM_TYPE_SMS_QMI, - MM_BASE_SMS_MODEM, modem, - MM_BIND_TO, G_OBJECT (modem), - MM_BASE_SMS_IS_3GPP, is_3gpp, - MM_BASE_SMS_DEFAULT_STORAGE, default_storage, - NULL)); + MMBaseSms *sms; + + g_return_val_if_fail (MM_IS_BROADBAND_MODEM_QMI (modem), NULL); + + sms = MM_BASE_SMS (g_object_new (MM_TYPE_SMS_QMI, + MM_BIND_TO, G_OBJECT (modem), + MM_BASE_SMS_IS_3GPP, is_3gpp, + MM_BASE_SMS_DEFAULT_STORAGE, default_storage, + NULL)); + MM_SMS_QMI (sms)->priv->modem = g_object_ref (modem); + return sms; } static void mm_sms_qmi_init (MMSmsQmi *self) { + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_SMS_QMI, MMSmsQmiPrivate); +} + +static void +dispose (GObject *object) +{ + MMSmsQmi *self = MM_SMS_QMI (object); + + g_clear_object (&self->priv->modem); + + G_OBJECT_CLASS (mm_sms_qmi_parent_class)->dispose (object); } static void mm_sms_qmi_class_init (MMSmsQmiClass *klass) { + GObjectClass *object_class = G_OBJECT_CLASS (klass); MMBaseSmsClass *base_sms_class = MM_BASE_SMS_CLASS (klass); + g_type_class_add_private (object_class, sizeof (MMSmsQmiPrivate)); + + object_class->dispose = dispose; + base_sms_class->store = sms_store; base_sms_class->store_finish = sms_store_finish; base_sms_class->send = sms_send; diff --git a/src/mm-sms-qmi.h b/src/mm-sms-qmi.h index 1dda2a95..e59ff4ec 100644 --- a/src/mm-sms-qmi.h +++ b/src/mm-sms-qmi.h @@ -35,9 +35,11 @@ typedef struct _MMSmsQmi MMSmsQmi; typedef struct _MMSmsQmiClass MMSmsQmiClass; +typedef struct _MMSmsQmiPrivate MMSmsQmiPrivate; struct _MMSmsQmi { MMBaseSms parent; + MMSmsQmiPrivate *priv; }; struct _MMSmsQmiClass { -- cgit v1.2.3-70-g09d2