Merge branch 'mr-origin-157'

plugins/mm/calls-mm-origin.c

@@ -24,6 +24,7 @@
 
 #include "calls-mm-origin.h"
 #include "calls-origin.h"
+#include "calls-ussd.h"
 #include "calls-mm-call.h"
 #include "calls-message-source.h"
 
@@ -35,16 +36,24 @@ struct _CallsMMOrigin
   GObject parent_instance;
   MMObject *mm_obj;
   MMModemVoice *voice;
+  MMModem3gppUssd *ussd;
+  char            *ussd_command;
+  gulong           ussd_handle_id;
+  gulong           response_handle_id;
+  gulong           request_handle_id;
   gchar *name;
   GHashTable *calls;
 };
 
 static void calls_mm_origin_message_source_interface_init (CallsOriginInterface *iface);
 static void calls_mm_origin_origin_interface_init (CallsOriginInterface *iface);
+static void calls_mm_origin_ussd_interface_init (CallsUssdInterface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (CallsMMOrigin, calls_mm_origin, G_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (CALLS_TYPE_MESSAGE_SOURCE,
                                                 calls_mm_origin_message_source_interface_init)
+                         G_IMPLEMENT_INTERFACE (CALLS_TYPE_USSD,
+                                                calls_mm_origin_ussd_interface_init)
                          G_IMPLEMENT_INTERFACE (CALLS_TYPE_ORIGIN,
                                                 calls_mm_origin_origin_interface_init))
 
@@ -56,6 +65,149 @@ enum {
 static GParamSpec *props[PROP_LAST_PROP];
 
 
+static void
+ussd_initiate_cb (GObject      *object,
+                  GAsyncResult *result,
+                  gpointer      user_data)
+{
+  MMModem3gppUssd *ussd = (MMModem3gppUssd *)object;
+  CallsMMOrigin *self = user_data;
+  g_autofree char *response = NULL;
+  g_autoptr(GError) error = NULL;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+  g_assert (MM_IS_MODEM_3GPP_USSD (ussd));
+
+  response = mm_modem_3gpp_ussd_initiate_finish (ussd, result, &error);
+  g_clear_pointer (&self->ussd_command, g_free);
+
+  if (error)
+    g_warning ("USSD Initiate Error: %s", error->message);
+
+  if (response)
+    g_signal_emit_by_name (self, "ussd-added", response);
+  else
+    g_signal_emit_by_name (self, "ussd-cancelled");
+}
+
+static void
+ussd_initiate (GObject      *object,
+               GAsyncResult *result,
+               gpointer      user_data)
+{
+  MMModem3gppUssd *ussd = (MMModem3gppUssd *)object;
+  CallsMMOrigin *self = user_data;
+  g_autoptr(GError) error = NULL;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+  g_assert (MM_IS_MODEM_3GPP_USSD (ussd));
+
+  mm_modem_3gpp_ussd_cancel_finish (ussd, result, &error);
+
+  if (error)
+    g_warning ("USSD cancel Error: %s", error->message);
+
+  mm_modem_3gpp_ussd_initiate (self->ussd, self->ussd_command, NULL,
+                               ussd_initiate_cb, self);
+}
+
+static void
+ussd_respond_cb (GObject      *object,
+                 GAsyncResult *result,
+                 gpointer      user_data)
+{
+  MMModem3gppUssd *ussd = (MMModem3gppUssd *)object;
+  CallsMMOrigin *self = user_data;
+  g_autofree char *response = NULL;
+  g_autoptr(GError) error = NULL;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+  g_assert (MM_IS_MODEM_3GPP_USSD (ussd));
+
+  response = mm_modem_3gpp_ussd_respond_finish (ussd, result, &error);
+
+  if (error)
+    g_warning ("USSD respond Error: %s", error->message);
+
+  if (response)
+    g_signal_emit_by_name (self, "ussd-added", response);
+  else
+    g_signal_emit_by_name (self, "ussd-cancelled");
+}
+
+static void
+ussd_cancel_cb (GObject      *object,
+                GAsyncResult *result,
+                gpointer      user_data)
+{
+  MMModem3gppUssd *ussd = (MMModem3gppUssd *)object;
+  CallsMMOrigin *self = user_data;
+  g_autoptr(GError) error = NULL;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+  g_assert (MM_IS_MODEM_3GPP_USSD (ussd));
+
+  mm_modem_3gpp_ussd_cancel_finish (ussd, result, &error);
+
+  if (error)
+    g_warning ("Error: %s", error->message);
+
+  g_signal_emit_by_name (self, "ussd-cancelled");
+}
+
+static CallsUssdState
+calls_mm_ussd_get_state (CallsUssd *ussd)
+{
+  CallsMMOrigin *self = CALLS_MM_ORIGIN (ussd);
+
+  if (!self->ussd)
+    return CALLS_USSD_STATE_UNKNOWN;
+
+  return mm_modem_3gpp_ussd_get_state (self->ussd);
+}
+
+static void
+calls_mm_ussd_initiate (CallsUssd  *ussd,
+                        const char *command)
+{
+  CallsMMOrigin *self = CALLS_MM_ORIGIN (ussd);
+  CallsUssdState state;
+
+  if (!self->ussd || !command || !*command)
+    return;
+
+  g_free (self->ussd_command);
+  self->ussd_command = g_strdup (command);
+  state = calls_ussd_get_state (ussd);
+
+  if (state == CALLS_USSD_STATE_ACTIVE ||
+      state == CALLS_USSD_STATE_USER_RESPONSE)
+    mm_modem_3gpp_ussd_cancel (self->ussd, NULL,
+                               ussd_initiate, self);
+  else
+    mm_modem_3gpp_ussd_initiate (self->ussd, self->ussd_command, NULL,
+                                 ussd_initiate_cb, self);
+}
+
+static void
+calls_mm_ussd_respond (CallsUssd  *ussd,
+                       const char *response)
+{
+  CallsMMOrigin *self = CALLS_MM_ORIGIN (ussd);
+
+  mm_modem_3gpp_ussd_respond (self->ussd, response, NULL,
+                              ussd_respond_cb, self);
+}
+
+static void
+calls_mm_ussd_cancel (CallsUssd *ussd)
+{
+  CallsMMOrigin *self = CALLS_MM_ORIGIN (ussd);
+
+  mm_modem_3gpp_ussd_cancel (self->ussd, NULL,
+                             ussd_cancel_cb, self);
+}
+
 static const gchar *
 get_name (CallsOrigin *origin)
 {
@@ -427,6 +579,73 @@ modem_get_name (MMModem *modem)
 }
 
 
+static void
+call_mm_ussd_state_changed_cb (CallsMMOrigin *self)
+{
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+
+  g_signal_emit_by_name (self, "ussd-state-changed");
+}
+
+static void
+call_mm_network_request_cb (CallsMMOrigin *self)
+{
+  const char *response;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+
+  response = mm_modem_3gpp_ussd_get_network_request (self->ussd);
+
+  if (response)
+    g_signal_emit_by_name (self, "ussd-added", response);
+}
+
+static void
+call_mm_network_ussd_cb (CallsMMOrigin *self)
+{
+  const char *response;
+
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+
+  response = mm_modem_3gpp_ussd_get_network_notification (self->ussd);
+
+  if (response)
+    g_signal_emit_by_name (self, "ussd-added", response);
+}
+
+static void
+call_mm_ussd_changed_cb (CallsMMOrigin *self)
+{
+  g_assert (CALLS_IS_MM_ORIGIN (self));
+
+  if (self->ussd_handle_id)
+    g_signal_handler_disconnect (self, self->ussd_handle_id);
+  if (self->request_handle_id)
+    g_signal_handler_disconnect (self, self->request_handle_id);
+  if (self->response_handle_id)
+    g_signal_handler_disconnect (self, self->response_handle_id);
+
+  self->ussd_handle_id = 0;
+  self->request_handle_id = 0;
+  self->response_handle_id = 0;
+
+  g_clear_object (&self->ussd);
+  self->ussd = mm_object_get_modem_3gpp_ussd (self->mm_obj);
+
+  if (self->ussd)
+    {
+      self->ussd_handle_id = g_signal_connect_object (self->ussd, "notify::state",
+                                                      G_CALLBACK (call_mm_ussd_state_changed_cb), self,
+                                                      G_CONNECT_SWAPPED);
+      self->request_handle_id = g_signal_connect_object (self->ussd, "notify::network-request",
+                                                         G_CALLBACK (call_mm_network_request_cb), self,
+                                                         G_CONNECT_SWAPPED);
+      self->response_handle_id = g_signal_connect_object (self->ussd, "notify::network-notification",
+                                                          G_CALLBACK (call_mm_network_ussd_cb), self,
+                                                          G_CONNECT_SWAPPED);
+    }
+}
+
 static void
 constructed (GObject *object)
 {
@@ -435,6 +654,11 @@ constructed (GObject *object)
 
   self->name = modem_get_name (mm_object_get_modem (self->mm_obj));
 
+  g_signal_connect_object (self->mm_obj, "notify::modem3gpp-ussd",
+                           G_CALLBACK (call_mm_ussd_changed_cb), self,
+                           G_CONNECT_SWAPPED);
+  call_mm_ussd_changed_cb (self);
+
   self->voice = mm_object_get_modem_voice (self->mm_obj);
   g_assert (self->voice != NULL);
 
@@ -460,6 +684,7 @@ dispose (GObject *object)
 
   remove_calls (self, NULL);
   g_clear_object (&self->mm_obj);
+  g_clear_object (&self->ussd);
 
   G_OBJECT_CLASS (calls_mm_origin_parent_class)->dispose (object);
 }
@@ -472,6 +697,7 @@ finalize (GObject *object)
 
   g_hash_table_unref (self->calls);
   g_free (self->name);
+  g_free (self->ussd_command);
 
   G_OBJECT_CLASS (calls_mm_origin_parent_class)->finalize (object);
 }
@@ -504,6 +730,16 @@ calls_mm_origin_message_source_interface_init (CallsOriginInterface *iface)
 }
 
 
+static void
+calls_mm_origin_ussd_interface_init (CallsUssdInterface *iface)
+{
+  iface->get_state = calls_mm_ussd_get_state;
+  iface->initiate = calls_mm_ussd_initiate;
+  iface->respond = calls_mm_ussd_respond;
+  iface->cancel = calls_mm_ussd_cancel;
+}
+
+
 static void
 calls_mm_origin_origin_interface_init (CallsOriginInterface *iface)
 {

src/calls-main-window.c

@@ -24,6 +24,7 @@
 
 #include "calls-main-window.h"
 #include "calls-origin.h"
+#include "calls-ussd.h"
 #include "calls-call-holder.h"
 #include "calls-call-selector-item.h"
 #include "calls-new-call-box.h"
@@ -59,6 +60,12 @@ struct _CallsMainWindow
   GtkLabel *permanent_error_label;
 
   CallsNewCallBox *new_call;
+
+  HdyDialog *ussd_dialog;
+  GtkLabel  *ussd_label;
+  GtkEntry  *ussd_entry;
+  GtkButton *ussd_cancel_button;
+  GtkButton *ussd_reply_button;
 };
 
 G_DEFINE_TYPE (CallsMainWindow, calls_main_window, GTK_TYPE_APPLICATION_WINDOW);
@@ -137,6 +144,91 @@ set_switcher_bar_reveal (GBinding     *binding,
 }
 
 
+static void
+window_update_ussd_state (CallsMainWindow *self,
+                          CallsUssd       *ussd)
+{
+  CallsUssdState state;
+
+  g_assert (CALLS_IS_MAIN_WINDOW (self));
+  g_assert (CALLS_IS_USSD (ussd));
+
+  state = calls_ussd_get_state (ussd);
+
+  /* If state changed in an active USSD session, don't update */
+  if (state == CALLS_USSD_STATE_ACTIVE &&
+      gtk_widget_get_visible (GTK_WIDGET (self->ussd_reply_button)))
+    return;
+
+  gtk_widget_set_visible (GTK_WIDGET (self->ussd_reply_button),
+                          state == CALLS_USSD_STATE_USER_RESPONSE);
+  gtk_widget_set_visible (GTK_WIDGET (self->ussd_entry),
+                          state == CALLS_USSD_STATE_USER_RESPONSE);
+
+  if (state == CALLS_USSD_STATE_USER_RESPONSE)
+    gtk_button_set_label (self->ussd_cancel_button, _("Cancel"));
+  else
+    gtk_button_set_label (self->ussd_cancel_button, _("Close"));
+}
+
+static void
+window_ussd_added_cb (CallsMainWindow *self,
+                      CallsUssd       *ussd,
+                      char            *response)
+{
+  int result;
+
+  g_assert (CALLS_IS_MAIN_WINDOW (self));
+  g_assert (CALLS_IS_USSD (ussd));
+
+  if (!response || !*response)
+    return;
+
+  gtk_label_set_label (self->ussd_label, response);
+  g_object_set_data_full (G_OBJECT (self->ussd_dialog), "ussd",
+                          g_object_ref (ussd), g_object_unref);
+  window_update_ussd_state (self, ussd);
+  result = gtk_dialog_run (GTK_DIALOG (self->ussd_dialog));
+
+  if (result == GTK_RESPONSE_CANCEL)
+    {
+      calls_ussd_cancel (ussd);
+      gtk_window_close (GTK_WINDOW (self->ussd_dialog));
+    }
+}
+
+static void
+window_ussd_entry_changed_cb (CallsMainWindow *self,
+                              GtkEntry        *entry)
+{
+  const char *text;
+  gboolean allow_send;
+
+  g_assert (CALLS_IS_MAIN_WINDOW (self));
+  g_assert (GTK_IS_ENTRY (entry));
+
+  text = gtk_entry_get_text (entry);
+  allow_send = text && *text;
+
+  gtk_widget_set_sensitive (GTK_WIDGET (self->ussd_reply_button), allow_send);
+}
+
+static void
+window_ussd_reply_clicked_cb (CallsMainWindow *self)
+{
+  CallsUssd *ussd;
+  g_autofree char *response = NULL;
+
+  g_assert (CALLS_IS_MAIN_WINDOW (self));
+
+  ussd = g_object_get_data (G_OBJECT (self->ussd_dialog), "ussd");
+  g_assert (CALLS_IS_USSD (ussd));
+
+  response = g_strdup (gtk_entry_get_text (self->ussd_entry));
+  gtk_entry_set_text (self->ussd_entry, "");
+  calls_ussd_respond (ussd, response);
+}
+
 static void
 set_property (GObject      *object,
               guint         property_id,
@@ -203,6 +295,16 @@ constructed (GObject *object)
                             G_CALLBACK (calls_in_app_notification_show),
                             self->in_app_notification);
 
+  g_signal_connect_swapped (calls_manager_get_default (),
+                            "ussd-added",
+                            G_CALLBACK (window_ussd_added_cb),
+                            self);
+  g_signal_connect_swapped (calls_manager_get_default (),
+                            "ussd-state-changed",
+                            G_CALLBACK (window_update_ussd_state),
+                            self);
+  gtk_window_set_transient_for (GTK_WINDOW (self->ussd_dialog), GTK_WINDOW (self));
+
   // Add new call box
   self->new_call = calls_new_call_box_new ();
   widget = GTK_WIDGET (self->new_call);
@@ -319,6 +421,15 @@ calls_main_window_class_init (CallsMainWindowClass *klass)
   gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, main_stack);
   gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, permanent_error_revealer);
   gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, permanent_error_label);
+
+  gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, ussd_dialog);
+  gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, ussd_label);
+  gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, ussd_entry);
+  gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, ussd_cancel_button);
+  gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, ussd_reply_button);
+
+  gtk_widget_class_bind_template_callback (widget_class, window_ussd_entry_changed_cb);
+  gtk_widget_class_bind_template_callback (widget_class, window_ussd_reply_clicked_cb);
 }
 
 

src/calls-manager.c

@@ -23,6 +23,7 @@
  */
 
 #include "config.h"
+#include "calls-ussd.h"
 #include "calls-manager.h"
 #include "calls-contacts.h"
 #include "enum-types.h"
@@ -61,6 +62,9 @@ enum {
   /* TODO: currently this event isn't emitted since the plugins don't give use
    * a usable error or error message. */
   SIGNAL_ERROR,
+  USSD_ADDED,
+  USSD_CANCELLED,
+  USSD_STATE_CHANGED,
   SIGNAL_LAST_SIGNAL,
 };
 static guint signals [SIGNAL_LAST_SIGNAL];
@@ -151,6 +155,38 @@ remove_call (CallsManager *self, CallsCall *call, gchar *reason, CallsOrigin *or
   g_signal_emit (self, signals[SIGNAL_CALL_REMOVE], 0, call, origin);
 }
 
+static void
+ussd_added_cb (CallsManager *self,
+               char         *response,
+               CallsUssd    *ussd)
+{
+  g_assert (CALLS_IS_MANAGER (self));
+  g_assert (CALLS_IS_USSD (ussd));
+
+  g_signal_emit (self, signals[USSD_ADDED], 0, ussd, response);
+}
+
+static void
+ussd_cancelled_cb (CallsManager *self,
+                   CallsUssd    *ussd,
+                   char         *response)
+{
+  g_assert (CALLS_IS_MANAGER (self));
+  g_assert (CALLS_IS_USSD (ussd));
+
+  g_signal_emit (self, signals[USSD_CANCELLED], 0, ussd);
+}
+
+static void
+ussd_state_changed_cb (CallsManager *self,
+                       CallsUssd    *ussd)
+{
+  g_assert (CALLS_IS_MANAGER (self));
+  g_assert (CALLS_IS_USSD (ussd));
+
+  g_signal_emit (self, signals[USSD_STATE_CHANGED], 0, ussd);
+}
+
 static void
 add_origin (CallsManager *self, CallsOrigin *origin, CallsProvider *provider)
 {
@@ -163,6 +199,13 @@ add_origin (CallsManager *self, CallsOrigin *origin, CallsProvider *provider)
   g_signal_connect_swapped (origin, "call-added", G_CALLBACK (add_call), self);
   g_signal_connect_swapped (origin, "call-removed", G_CALLBACK (remove_call), self);
 
+  if (CALLS_IS_USSD (origin))
+    {
+      g_signal_connect_swapped (origin, "ussd-added", G_CALLBACK (ussd_added_cb), self);
+      g_signal_connect_swapped (origin, "ussd-cancelled", G_CALLBACK (ussd_cancelled_cb), self);
+      g_signal_connect_swapped (origin, "ussd-state-changed", G_CALLBACK (ussd_state_changed_cb), self);
+    }
+
   for (c = calls; c != NULL; c = c->next)
     {
       add_call (self, c->data, origin);
@@ -380,6 +423,37 @@ calls_manager_class_init (CallsManagerClass *klass)
                  1,
                  G_TYPE_STRING);
 
+  signals[USSD_ADDED] =
+    g_signal_new ("ussd-added",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  2,
+                  CALLS_TYPE_USSD,
+                  G_TYPE_STRING);
+
+  signals[USSD_CANCELLED] =
+    g_signal_new ("ussd-cancelled",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  1,
+                  CALLS_TYPE_USSD);
+
+  signals[USSD_STATE_CHANGED] =
+    g_signal_new ("ussd-state-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  1,
+                  CALLS_TYPE_USSD);
+
   props[PROP_PROVIDER] = g_param_spec_string ("provider",
                                               "provider", 
                                               "The name of the currently loaded provider",

src/calls-new-call-box.c

@@ -23,6 +23,7 @@
  */
 
 #include "calls-new-call-box.h"
+#include "calls-ussd.h"
 #include "calls-manager.h"
 
 #include <glib/gi18n.h>
@@ -292,12 +293,27 @@ void
 calls_new_call_box_dial (CallsNewCallBox *self,
                          const gchar     *target)
 {
-  CallsOrigin *origin;
+  g_autoptr(CallsOrigin) origin = NULL;
 
   g_return_if_fail (CALLS_IS_NEW_CALL_BOX (self));
   g_return_if_fail (target != NULL);
 
   origin = get_origin (self);
+
+  if (calls_number_is_ussd (target))
+    {
+      GtkWidget *entry = hdy_keypad_get_entry (self->keypad);
+
+      if (origin)
+        calls_ussd_initiate (CALLS_USSD (origin), target);
+      else
+        g_debug ("Ignoring USSD request as no origin available");
+
+      gtk_editable_delete_text (GTK_EDITABLE (entry), 0, -1);
+
+      return;
+    }
+
   if (!origin)
     {
       // Queue for dialing when an origin appears
@@ -308,5 +324,4 @@ calls_new_call_box_dial (CallsNewCallBox *self,
     }
 
   calls_origin_dial (origin, target);
-  g_object_unref (origin);
 }

src/calls-ussd.c

+/*
+ * Copyright (C) 2020 Purism SPC
+ *
+ * This file is part of Calls.
+ *
+ * Calls is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Calls is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Calls.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Mohammed Sadiq <sadiq@sadiqpk.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#include "calls-ussd.h"
+#include "enum-types.h"
+#include "util.h"
+
+/**
+ * SECTION:calls-origin
+ * @short_description: An object that originates calls.
+ * @Title: CallsOrigin
+ */
+
+
+G_DEFINE_INTERFACE (CallsUssd, calls_ussd, G_TYPE_OBJECT)
+
+enum {
+  USSD_ADDED,
+  USSD_CANCELLED,
+  USSD_STATE_CHANGED,
+  N_SIGNALS
+};
+
+static guint signals [N_SIGNALS];
+
+static void
+calls_ussd_default_init (CallsUssdInterface *iface)
+{
+  /**
+   * CallsUssd::ussd-added:
+   * @self: a #CallsUssd
+   * @response: a string
+   *
+   * Emitted when some USSD response is recieved
+   */
+  signals[USSD_ADDED] =
+    g_signal_new ("ussd-added",
+                  CALLS_TYPE_USSD,
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL,
+                  G_TYPE_NONE,
+                  1, G_TYPE_STRING);
+
+  /**
+   * CallsUssd::ussd-cancelled:
+   * @self: a #CallsUssd
+   *
+   * Emitted when the active USSD is cancelled.  Shouldn't
+   * be emitted if cancelled to immidiately request again.
+   */
+  signals[USSD_CANCELLED] =
+    g_signal_new ("ussd-cancelled",
+                  CALLS_TYPE_USSD,
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
+  /**
+   * CallsUssd::ussd-state-changed:
+   * @self: a #CallsUssd
+   *
+   * Emitted when the USSD state changes.  Use
+   * calls_ussd_get_state() to get the state.
+   */
+  signals[USSD_STATE_CHANGED] =
+    g_signal_new ("ussd-state-changed",
+                  CALLS_TYPE_USSD,
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+}
+
+CallsUssdState
+calls_ussd_get_state (CallsUssd *self)
+{
+  CallsUssdInterface *iface;
+
+  g_return_val_if_fail (CALLS_IS_USSD (self), CALLS_USSD_STATE_UNKNOWN);
+
+  iface = CALLS_USSD_GET_IFACE (self);
+
+  if (!iface->get_state)
+    return CALLS_USSD_STATE_UNKNOWN;
+
+  return iface->get_state (self);
+}
+
+void
+calls_ussd_initiate (CallsUssd  *self,
+                     const char *command)
+{
+  CallsUssdInterface *iface;
+
+  g_return_if_fail (CALLS_IS_USSD (self));
+  g_return_if_fail (command);
+
+  iface = CALLS_USSD_GET_IFACE (self);
+
+  if (iface->initiate)
+    iface->initiate (self, command);
+}
+
+void
+calls_ussd_respond (CallsUssd  *self,
+                    const char *response)
+{
+  CallsUssdInterface *iface;
+
+  g_return_if_fail (CALLS_IS_USSD (self));
+  g_return_if_fail (response);
+
+  iface = CALLS_USSD_GET_IFACE (self);
+
+  if (iface->respond)
+    iface->respond (self, response);
+}