ring-connection: use new modem and sim objects

Connection gets connected once it finds suitable modem: modem can be
specified by IMSI or object path.

Modem selection code also supports IMEI, but the account information
does not contain IMEI.

1 files changed, 348 insertions, 269 deletions

diff --git a/src/ring-connection.c b/src/ring-connection.c
index 432f041..eb07b6f 100644
--- a/src/ring-connection.c
+++ b/src/ring-connection.c
@@ -66,6 +66,8 @@
 struct _RingConnectionPrivate
 {
   /* Properties */
+  char *imsi;
+  char *imei;
   char *smsc;
   guint sms_valid;
   guint anon_modes;
@@ -81,8 +83,8 @@ struct _RingConnectionPrivate
   struct {
     gulong modem_added;
     gulong modem_removed;
-    gulong modem_interfaces;
-    gulong sim_connected;
+    gulong modem_interface_added;
+    gulong modem_interface_removed;
     gulong imsi_notify;
   } signals;
 
@@ -109,9 +111,13 @@ enum {
   PROP_ANON_MANDATORY,
   PROP_ANON_MODES,
 
+  PROP_MODEM,
+  PROP_SIM_SERVICE,
+
   N_PROPS
 };
 
+
 static void ring_connection_class_init_base_connection(TpBaseConnectionClass *);
 static void ring_connection_capabilities_iface_init(gpointer, gpointer);
 static void ring_connection_add_contact_capabilities(GObject *object,
@@ -133,6 +139,8 @@ ring_connection_dbus_property_interfaces[];
 /** Inspection result from self handle. */
 static char const ring_self_handle_name[] = "<SelfHandle>";
 
+#define METHOD(i, m) (i ## _ ## m)
+
 /* ---------------------------------------------------------------------- */
 /* GObject interface */
 
@@ -192,21 +200,6 @@ ring_connection_init(RingConnection *self)
 }
 
 static void
-on_imsi_changed(GObject *object, GParamSpec *pspec,
-  gpointer user_data)
-{
-  RingConnection *self = RING_CONNECTION(user_data);
-  TpBaseConnection *base = TP_BASE_CONNECTION(self);
-
-  if (base->status == TP_CONNECTION_STATUS_CONNECTED) {
-    char const *imsi;
-
-    imsi = modem_sim_get_imsi(MODEM_SIM_SERVICE(object));
-    tp_svc_connection_interface_cellular_emit_imsi_changed(self, imsi);
-  }
-}
-
-static void
 ring_connection_constructed(GObject *object)
 {
   RingConnection *self = RING_CONNECTION(object);
@@ -266,6 +259,7 @@ ring_connection_finalize(GObject *object)
   DEBUG("enter %p", object);
 
   /* Free any data held directly by the object here */
+  g_free (priv->imsi);
   g_free(priv->smsc);
   g_free(priv->modem_path);
 
@@ -278,26 +272,38 @@ ring_connection_set_property(GObject *obj,
   const GValue *value,
   GParamSpec *pspec)
 {
-  TpBaseConnection *base;
-  RingConnection *self = RING_CONNECTION(obj);
+  RingConnection *self = RING_CONNECTION (obj);
+  TpBaseConnection *base = TP_BASE_CONNECTION (obj);
   RingConnectionPrivate *priv = self->priv;
+  gpointer p;
+
+  switch (property_id)
+    {
+    case PROP_IMSI:
+      priv->imsi = g_value_dup_string (value);
+      if (base->status == TP_CONNECTION_STATUS_CONNECTED)
+        METHOD (tp_svc_connection_interface_cellular,
+            emit_imsi_changed) (self, priv->imsi);
+      break;
 
-  switch (property_id) {
     case PROP_SMSC:
       priv->smsc = ring_normalize_isdn(g_value_get_string(value));
       if (priv->text)
         g_object_set(priv->text, "sms-service-centre", priv->smsc, NULL);
       break;
+
     case PROP_SMS_VALID:
       priv->sms_valid = g_value_get_uint(value);
       if (priv->text)
-        g_object_set(priv->text, "sms-validity-period", priv->sms_valid, NULL);
+        g_object_set_property (G_OBJECT (priv->text),
+            "sms-validity-period", value);
       break;
+
     case PROP_SMS_REDUCED_CHARSET:
       priv->sms_reduced_charset = g_value_get_boolean(value);
       if (priv->text)
-        g_object_set(priv->text, "sms-reduced-charset",
-          priv->sms_reduced_charset, NULL);
+        g_object_set_property (G_OBJECT (priv->text),
+            "sms-reduced-charset", value);
       break;
 
     case PROP_MODEM_PATH:
@@ -309,15 +315,27 @@ ring_connection_set_property(GObject *obj,
       break;
 
     case PROP_ANON_MODES:
-      base = TP_BASE_CONNECTION(self);
-
       priv->anon_modes = g_value_get_uint(value);
       if (priv->media)
-        g_object_set(priv->media, "anon-modes", priv->anon_modes, NULL);
+        g_object_set_property (G_OBJECT (priv->media), "anon-modes", value);
 
       if (base->status == TP_CONNECTION_STATUS_CONNECTED)
-        tp_svc_connection_interface_anonymity_emit_anonymity_modes_changed
-          (self, priv->anon_modes);
+        METHOD (tp_svc_connection_interface_anonymity,
+            emit_anonymity_modes_changed) (self, priv->anon_modes);
+      break;
+
+    case PROP_MODEM:
+      if (priv->modem)
+        g_object_unref (priv->modem);
+      p = g_value_get_pointer (value);
+      priv->modem = p ? g_object_ref (p) : NULL;
+      break;
+
+    case PROP_SIM_SERVICE:
+      if (priv->sim)
+        g_object_unref (priv->sim);
+      p = g_value_get_pointer (value);
+      priv->sim = p ? g_object_ref (p) : NULL;
       break;
 
     default:
@@ -337,10 +355,7 @@ ring_connection_get_property(GObject *obj,
 
   switch (property_id) {
     case PROP_IMSI:
-      if (priv->sim && modem_sim_service_is_connected(priv->sim))
-        g_object_get_property(G_OBJECT(priv->sim), "imsi", value);
-      else
-        g_value_set_string(value, "");
+      g_value_set_string (value, priv->imsi);
       break;
     case PROP_SMSC:
       g_value_set_string(value, priv->smsc ? priv->smsc : "");
@@ -374,6 +389,14 @@ ring_connection_get_property(GObject *obj,
       g_value_set_uint(value, priv->anon_modes);
       break;
 
+    case PROP_MODEM:
+      g_value_set_object (value, priv->modem);
+      break;
+
+    case PROP_SIM_SERVICE:
+      g_value_set_object (value, priv->sim);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
       break;
@@ -457,6 +480,20 @@ ring_connection_class_init(RingConnectionClass *ring_connection_class)
     object_class, PROP_ANON_MODES,
     ring_param_spec_anon_modes());
 
+  g_object_class_install_property (object_class,
+      PROP_MODEM,
+      g_param_spec_pointer ("modem",
+          "Modem Object",
+          "The oFono modem object",
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class,
+      PROP_SIM_SERVICE,
+      g_param_spec_pointer ("sim-service",
+          "SIM Manager Object",
+          "The SIM manager from the modem",
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
   ring_connection_class_init_base_connection(
     TP_BASE_CONNECTION_CLASS(ring_connection_class));
 
@@ -600,6 +637,7 @@ TpCMParamSpec ring_connection_params[] = {
     DBUS_TYPE_STRING_AS_STRING, G_TYPE_STRING,
     TP_CONN_MGR_PARAM_FLAG_DBUS_PROPERTY,
     "",
+    .setter_data = "imsi",
   },
 
 #define CELLULAR_SMS_VALIDITY_PERIOD_PARAM_SPEC (ring_connection_params + 1)
@@ -849,185 +887,163 @@ ring_connection_create_channel_managers(TpBaseConnection *base)
   return channel_managers;
 }
 
-static gboolean ring_connection_connecting_timeout (gpointer);
-static void ring_connection_sim_connected(ModemSIMService *, gpointer);
-static void ring_connection_modem_added (ModemService *, Modem *, gpointer);
-static void ring_connection_modem_removed (ModemService *, Modem *, gpointer);
-static void on_modem_interfaces_changed (Modem *, GParamSpec *, gpointer);
-
-static gboolean
-ring_connection_start_connecting(TpBaseConnection *base,
-  GError **return_error)
+static void
+ring_connection_imsi_changed (ModemSIMService *sim,
+                              GParamSpec *dummy,
+                              gpointer _self)
 {
-  RingConnection *self = RING_CONNECTION(base);
-  RingConnectionPrivate *priv = self->priv;
-  ModemService *modems;
-  Modem *modem;
-  GError *error = NULL;
+  TpBaseConnection *base = TP_BASE_CONNECTION (_self);
 
-  DEBUG("called");
+  DEBUG ("enter");
 
-  g_assert(base->status == TP_INTERNAL_CONNECTION_STATUS_NEW);
+  if (RING_CONNECTION (_self)->priv->sim != sim)
+    return;
 
-  error = NULL;
+  if (base->status != TP_CONNECTION_STATUS_DISCONNECTED)
+    {
+      tp_base_connection_change_status (base,
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+    }
+}
 
-  priv->connecting_source = g_timeout_add_seconds (30,
-      ring_connection_connecting_timeout, self);
+static void
+ring_connection_modem_interface_added (Modem *modem,
+                                       ModemOface *oface,
+                                       gpointer _self)
+{
+  RingConnection *self = RING_CONNECTION (_self);
+  RingConnectionPrivate *priv = self->priv;
 
-  modems = modem_service ();
-  modem = modem_service_find_modem (modems, priv->modem_path);
+  DEBUG ("enter with %s of %s",
+      modem_oface_interface (oface), modem_oface_object_path (oface));
 
-  if (modem)
+  if (MODEM_IS_SIM_SERVICE (oface))
     {
-      ring_connection_modem_added (modems, modem, self);
+      g_object_set (self, "sim-service", oface, NULL);
+
+      if (priv->imsi)
+        {
+          priv->signals.imsi_notify =
+            g_signal_connect (priv->sim, "notify::imsi",
+                G_CALLBACK (ring_connection_imsi_changed), self);
+        }
     }
-  else
+  else if (MODEM_IS_CALL_SERVICE (oface))
     {
-      priv->signals.modem_added = g_signal_connect (modems,
-          "modem-added", G_CALLBACK (ring_connection_modem_added), self);
+      g_object_set (priv->media, "call-service", oface, NULL);
+    }
+  else if (MODEM_IS_SMS_SERVICE (oface))
+    {
+      g_object_set (priv->text, "sms-service", oface, NULL);
     }
-
-  priv->signals.modem_removed = g_signal_connect (modems,
-      "modem-removed", G_CALLBACK (ring_connection_modem_removed), self);
-
-  return TRUE;
 }
 
-/**
- * ring_connection_connected
- *
- * Called after a connection becomes connected.
- */
 static void
-ring_connection_connected (TpBaseConnection *base)
+ring_connection_modem_interface_removed (Modem *modem,
+                                         ModemOface *oface,
+                                         gpointer _self)
 {
-  RingConnection *self = RING_CONNECTION (base);
+  RingConnection *self = RING_CONNECTION (_self);
   RingConnectionPrivate *priv = self->priv;
 
-  DEBUG ("called");
+  DEBUG ("enter with %s of %s",
+      modem_oface_interface (oface), modem_oface_object_path (oface));
 
-  if (priv->connecting_source)
+  if (MODEM_IS_SIM_SERVICE (oface))
     {
-      g_source_remove (priv->connecting_source);
-      priv->connecting_source = 0;
+      DEBUG ("active SIM_SERVICE");
+      g_object_set (self, "sim-service", NULL, NULL);
+    }
+  else if (MODEM_IS_CALL_SERVICE (oface))
+    {
+      DEBUG ("active CALL_SERVICE");
+      g_assert (priv->media);
+      g_object_set (priv->media, "call-service", NULL, NULL);
+    }
+  else if (MODEM_IS_SMS_SERVICE (oface))
+    {
+      DEBUG ("active SMS_SERVICE");
+      g_assert (priv->text);
+      g_object_set (priv->text, "sms-service", NULL, NULL);
     }
 }
 
-/**
- * ring_connection_disconnected
- *
- * Called after a connection becomes disconnected.
- *
- * Not called unless start_connecting has been called.
- */
 static void
-ring_connection_disconnected(TpBaseConnection *base)
+ring_connection_bind_modem (RingConnection *self,
+                            Modem *modem)
 {
-  RingConnection *self = RING_CONNECTION(base);
   RingConnectionPrivate *priv = self->priv;
+  TpBaseConnection *base = TP_BASE_CONNECTION (self);
 
-  DEBUG("called");
+  g_assert (base->status == TP_CONNECTION_STATUS_CONNECTING ||
+            base->status == TP_INTERNAL_CONNECTION_STATUS_NEW);
 
-  if (priv->connecting_source)
-    {
-      g_source_remove (priv->connecting_source);
-      priv->connecting_source = 0;
-    }
+  g_return_if_fail (MODEM_IS_MODEM (modem));
+  g_return_if_fail (priv->modem == NULL);
 
-  if (priv->sim)
-    modem_sim_service_disconnect(priv->sim);
+  g_object_set (self, "modem", modem, NULL);
+
+  tp_base_connection_change_status (base,
+      TP_CONNECTION_STATUS_CONNECTED,
+      TP_CONNECTION_STATUS_REASON_REQUESTED);
 }
 
-/** Called after connection has been disconnected.
- *
- * Shuts down connection and eventually calls
- * tp_base_connection_finish_shutdown().
- */
-static void
-ring_connection_shut_down(TpBaseConnection *base)
+static gboolean
+ring_connection_connecting_timeout (gpointer _self)
 {
-  RingConnection *self = RING_CONNECTION(base);
+  RingConnection *self = RING_CONNECTION (_self);
+  TpBaseConnection *base = TP_BASE_CONNECTION (_self);
   RingConnectionPrivate *priv = self->priv;
 
-  DEBUG("called");
-
-  if (priv->signals.modem_added)
-    {
-      g_signal_handler_disconnect (modem_service (),
-          priv->signals.modem_added);
-      priv->signals.modem_added = 0;
-    }
+  DEBUG ("enter");
 
-  if (priv->signals.modem_removed)
-    {
-      g_signal_handler_disconnect (modem_service (),
-          priv->signals.modem_removed);
-      priv->signals.modem_removed = 0;
-    }
+  priv->connecting_source = 0;
 
-  if (priv->signals.modem_interfaces)
+  if (base->status != TP_CONNECTION_STATUS_DISCONNECTED)
     {
-      g_signal_handler_disconnect(priv->modem,
-          priv->signals.modem_interfaces);
-      priv->signals.modem_interfaces = 0;
+      tp_base_connection_change_status (base,
+          TP_CONNECTION_STATUS_DISCONNECTED,
+          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
     }
 
-  if (priv->signals.sim_connected) {
-    g_signal_handler_disconnect(priv->sim, priv->signals.sim_connected);
-    priv->signals.sim_connected = 0;
-  }
-
-  if (priv->signals.imsi_notify) {
-    g_signal_handler_disconnect(priv->sim, priv->signals.imsi_notify);
-    priv->signals.imsi_notify = 0;
-  }
-
-  tp_base_connection_finish_shutdown(base);
+  return FALSE;
 }
 
 static void
-ring_connection_class_init_base_connection(TpBaseConnectionClass *klass)
+ring_connection_imsi_added (ModemService *modems,
+                            Modem *modem,
+                            char const *imsi,
+                            gpointer _self)
 {
-  /* Implement pure-virtual methods */
-#define IMPLEMENT(x) klass->x = ring_connection_##x
-  IMPLEMENT(create_handle_repos);
-  /* IMPLEMENT(create_channel_factories); */
-  IMPLEMENT(get_unique_connection_name);
-
-  /* IMPLEMENT(connecting) */
-  IMPLEMENT (connected);
-  IMPLEMENT(disconnected);
-  IMPLEMENT(shut_down);
-  IMPLEMENT(start_connecting);
+  RingConnection *self = RING_CONNECTION (_self);
+  RingConnectionPrivate *priv = self->priv;
 
-  klass->interfaces_always_present =
-    (char const **)ring_connection_interfaces_always_present;
-  IMPLEMENT(create_channel_managers);
-#undef IMPLEMENT
-}
+  DEBUG ("enter with imsi=%s", imsi);
 
-/* ---------------------------------------------------------------------- */
-/* RingConnection interface */
+  if (priv->modem)
+    return;
 
-gchar **
-ring_connection_dup_implemented_interfaces (void)
-{
-  return g_strdupv ((GStrv)ring_connection_interfaces_always_present);
+  if (modem_has_imsi (modem, priv->imsi))
+    ring_connection_bind_modem (self, modem);
 }
 
-static gboolean
-ring_connection_connecting_timeout (gpointer _self)
+static void
+ring_connection_imei_added (ModemService *modems,
+                            Modem *modem,
+                            char const *imei,
+                            gpointer _self)
 {
   RingConnection *self = RING_CONNECTION (_self);
   RingConnectionPrivate *priv = self->priv;
 
-  DEBUG ("enter");
-
-  priv->connecting_source = 0;
+  DEBUG ("enter with imei=%s", imei);
 
-  ring_connection_check_status (self);
+  if (priv->modem)
+    return;
 
-  return FALSE;
+  if (modem_has_imei (modem, priv->imei))
+    ring_connection_bind_modem (self, modem);
 }
 
 static void
@@ -1037,27 +1053,32 @@ ring_connection_modem_added (ModemService *modems,
 {
   RingConnection *self = RING_CONNECTION (_self);
   RingConnectionPrivate *priv = self->priv;
-  char const *path;
 
-  DEBUG ("enter");
+  DEBUG ("enter with modem %s", modem_get_modem_path (modem));
 
   if (priv->modem)
     return;
 
-  path = modem_get_modem_path (modem);
-  g_assert (path != NULL);
-  g_assert (priv->sim == NULL);
-
-  if (priv->modem_path && strcmp (priv->modem_path, path))
+  if (strcmp (priv->modem_path, modem_get_modem_path (modem)))
     return;
 
-  priv->modem = g_object_ref (modem);
+  ring_connection_bind_modem (self, modem);
+}
 
-  priv->signals.modem_interfaces = g_signal_connect (modem,
-      "notify::interfaces",
-      G_CALLBACK (on_modem_interfaces_changed), self);
+static void
+ring_connection_modem_powered (ModemService *modems,
+                               Modem *modem,
+                               gpointer _self)
+{
+  RingConnection *self = RING_CONNECTION (_self);
+  RingConnectionPrivate *priv = self->priv;
+
+  DEBUG ("enter with modem %s", modem_get_modem_path (modem));
+
+  if (priv->modem)
+    return;
 
-  on_modem_interfaces_changed (modem, NULL, self);
+  ring_connection_bind_modem (self, modem);
 }
 
 static void
@@ -1066,12 +1087,10 @@ ring_connection_modem_removed (ModemService *modems,
                                gpointer _self)
 {
   TpBaseConnection *base = TP_BASE_CONNECTION (_self);
-  RingConnection *self = RING_CONNECTION (_self);
-  RingConnectionPrivate *priv = self->priv;
 
   DEBUG ("enter");
 
-  if (priv->modem != modem)
+  if (RING_CONNECTION (_self)->priv->modem != modem)
     return;
 
   if (base->status != TP_CONNECTION_STATUS_DISCONNECTED)
@@ -1082,132 +1101,192 @@ ring_connection_modem_removed (ModemService *modems,
     }
 }
 
-static void
-on_modem_interfaces_changed (Modem *modem,
-                             GParamSpec *spec,
-                             gpointer _self)
+static gboolean
+ring_connection_start_connecting(TpBaseConnection *base,
+    GError **return_error)
 {
-  RingConnection *self = RING_CONNECTION (_self);
+  RingConnection *self = RING_CONNECTION(base);
   RingConnectionPrivate *priv = self->priv;
-  char const *path = modem_get_modem_path (modem);
+  ModemService *manager;
+  Modem *modem;
   GError *error = NULL;
 
-  if (modem_supports_sim (modem))
-    {
-      if (!priv->sim)
-        {
-          priv->sim = g_object_new (MODEM_TYPE_SIM_SERVICE,
-              "object-path", path, NULL);
+  DEBUG("called");
 
-          priv->signals.sim_connected =
-            g_signal_connect (priv->sim, "connected",
-                G_CALLBACK (ring_connection_sim_connected), self);
+  g_assert(base->status == TP_INTERNAL_CONNECTION_STATUS_NEW);
 
-          priv->signals.imsi_notify =
-            g_signal_connect (self->priv->sim, "notify::imsi",
-                G_CALLBACK (on_imsi_changed), self);
+  error = NULL;
 
-          if (!modem_sim_service_connect (priv->sim))
-            DEBUG ("modem_sim_service_connect failed");
-        }
-    }
+  priv->connecting_source = g_timeout_add_seconds (30,
+      ring_connection_connecting_timeout, self);
+
+  manager = modem_service ();
 
-  if (modem_supports_call (modem))
+  if (priv->imsi && strlen (priv->imsi))
     {
-      if (!ring_media_manager_start_connecting (priv->media, path, &error))
-        {
-          DEBUG ("ring_media_manager_start_connecting: " GERROR_MSG_FMT,
-              GERROR_MSG_CODE (error));
-          g_clear_error (&error);
-        }
+      /* Connect to modem with IMSI */
+      modem = modem_service_find_by_imsi (manager, priv->imsi);
+      if (!modem)
+        priv->signals.modem_added = g_signal_connect (manager,
+          "imsi-added", G_CALLBACK (ring_connection_imsi_added), self);
+    }
+  else if (priv->imei && strlen (priv->imei))
+    {
+      /* Connect to modem with given IMEI */
+      modem = modem_service_find_by_imei (manager, priv->imei);
+      if (!modem)
+        priv->signals.modem_added = g_signal_connect (manager,
+          "imei-added", G_CALLBACK (ring_connection_imei_added), self);
+    }
+  else if (priv->modem_path)
+    {
+      /* Connect to modem with given path */
+      modem = modem_service_find_by_path (manager, priv->modem_path);
+      if (!modem)
+        priv->signals.modem_added = g_signal_connect (manager,
+            "modem-added", G_CALLBACK (ring_connection_modem_added), self);
+    }
+  else
+    {
+      /* Connect to first modem that is powered on */
+      modem = modem_service_find_best (manager);
+      if (!modem)
+        priv->signals.modem_added = g_signal_connect (manager,
+            "modem-powered", G_CALLBACK (ring_connection_modem_powered), self);
     }
 
-  if (modem_supports_sms (modem))
+  if (modem)
     {
-      if (!ring_text_manager_start_connecting (priv->text, path, &error))
-        {
-          DEBUG ("ring_text_manager_start_connecting: " GERROR_MSG_FMT,
-              GERROR_MSG_CODE (error));
-          g_clear_error (&error);
-        }
+      ring_connection_bind_modem (self, modem);
     }
 
-  ring_connection_check_status (self);
+  return TRUE;
 }
 
+/**
+ * ring_connection_connected
+ *
+ * Called after a connection becomes connected.
+ */
 static void
-ring_connection_sim_connected(ModemSIMService *sim,
-  gpointer _self)
+ring_connection_connected (TpBaseConnection *base)
 {
-  RingConnection *self = RING_CONNECTION(_self);
+  RingConnection *self = RING_CONNECTION (base);
+  RingConnectionPrivate *priv = self->priv;
+  ModemOface **interfaces;
+  int i;
 
-  DEBUG("enter");
+  DEBUG ("called");
+
+  if (priv->connecting_source)
+    {
+      g_source_remove (priv->connecting_source);
+      priv->connecting_source = 0;
+    }
+
+  ring_signal_disconnect (modem_service (), &priv->signals.modem_added);
+
+  priv->signals.modem_interface_added = g_signal_connect (priv->modem,
+      "interface-added",
+      G_CALLBACK (ring_connection_modem_interface_added), self);
+
+  priv->signals.modem_interface_removed = g_signal_connect (priv->modem,
+      "interface-removed",
+      G_CALLBACK (ring_connection_modem_interface_removed), self);
+
+  priv->signals.modem_removed = g_signal_connect (modem_service (),
+      "modem-removed",
+      G_CALLBACK (ring_connection_modem_removed), self);
+
+  interfaces = modem_list_interfaces (priv->modem);
+
+  if (interfaces)
+    {
+      for (i = 0; interfaces[i]; i++)
+        {
+          ModemOface *iface = interfaces[i];
+          ring_connection_modem_interface_added (priv->modem, iface, self);
+        }
+    }
+
+  g_free (interfaces);
 
-  ring_connection_check_status(self);
 }
 
-/* Check for status transition from connecting status */
-gboolean
-ring_connection_check_status(RingConnection *self)
+/**
+ * ring_connection_disconnected
+ *
+ * Called after a connection becomes disconnected.
+ *
+ * Not called unless start_connecting has been called.
+ */
+static void
+ring_connection_disconnected(TpBaseConnection *base)
 {
-  TpBaseConnection *base = TP_BASE_CONNECTION (self);
+  RingConnection *self = RING_CONNECTION(base);
   RingConnectionPrivate *priv = self->priv;
-  TpConnectionStatus conn, modem, sim, text, media;
-
-  conn = base->status;
-
-  modem = !priv->modem
-    ? TP_INTERNAL_CONNECTION_STATUS_NEW
-    : modem_is_powered (priv->modem)
-    ? TP_CONNECTION_STATUS_CONNECTED
-    : TP_CONNECTION_STATUS_CONNECTING;
-
-  sim = !priv->sim
-    ? TP_INTERNAL_CONNECTION_STATUS_NEW
-    : modem_sim_service_is_connected (priv->sim)
-    ? TP_CONNECTION_STATUS_CONNECTED
-    : modem_sim_service_is_connecting (priv->sim)
-    ? TP_CONNECTION_STATUS_CONNECTING
-    : TP_CONNECTION_STATUS_DISCONNECTED;
-
-  media = ring_media_manager_get_status(priv->media);
-  text = ring_text_manager_get_status(priv->text);
-
-  DEBUG ("%s - MODEM %s, SIM %s, CALL %s, SMS %s%s",
-      ring_connection_status_as_string (conn),
-      ring_connection_status_as_string (modem),
-      ring_connection_status_as_string (sim),
-      ring_connection_status_as_string (media),
-      ring_connection_status_as_string (text),
-      conn != TP_CONNECTION_STATUS_CONNECTING
-      ? ""
-      : priv->connecting_source
-      ? ", timer running" : ", timer expired");
-
-  if (modem == TP_CONNECTION_STATUS_CONNECTED &&
-      sim == TP_CONNECTION_STATUS_CONNECTED &&
-      (media == TP_CONNECTION_STATUS_CONNECTED ||
-          text == TP_CONNECTION_STATUS_CONNECTED))
-    {
-      if (base->status != TP_CONNECTION_STATUS_CONNECTED)
-        tp_base_connection_change_status (base,
-            TP_CONNECTION_STATUS_CONNECTED,
-            TP_CONNECTION_STATUS_REASON_REQUESTED);
 
-      return TRUE;
-    }
+  DEBUG("called");
 
   if (priv->connecting_source)
-    return TRUE;
-
-  if (base->status != TP_CONNECTION_STATUS_DISCONNECTED)
     {
-      tp_base_connection_change_status (base,
-          TP_CONNECTION_STATUS_DISCONNECTED,
-          TP_CONNECTION_STATUS_REASON_NETWORK_ERROR);
+      g_source_remove (priv->connecting_source);
+      priv->connecting_source = 0;
     }
 
-  return FALSE;
+  ring_signal_disconnect (modem_service (), &priv->signals.modem_added);
+  ring_signal_disconnect (modem_service (), &priv->signals.modem_removed);
+  ring_signal_disconnect (priv->modem, &priv->signals.modem_interface_added);
+  ring_signal_disconnect (priv->modem, &priv->signals.modem_interface_removed);
+  ring_signal_disconnect (priv->sim, &priv->signals.imsi_notify);
+
+  g_object_set (self, "modem", NULL, NULL);
+  g_object_set (self, "sim-service", NULL, NULL);
+  g_object_set (priv->media, "call-service", NULL, NULL);
+  g_object_set (priv->text, "sms-service", NULL, NULL);
+}
+
+/** Called after connection has been disconnected.
+ *
+ * Shuts down connection and eventually calls
+ * tp_base_connection_finish_shutdown().
+ */
+static void
+ring_connection_shut_down(TpBaseConnection *base)
+{
+  DEBUG("called");
+
+  tp_base_connection_finish_shutdown(base);
+}
+
+static void
+ring_connection_class_init_base_connection(TpBaseConnectionClass *klass)
+{
+  /* Implement pure-virtual methods */
+#define IMPLEMENT(x) klass->x = ring_connection_##x
+  IMPLEMENT(create_handle_repos);
+  /* IMPLEMENT(create_channel_factories); */
+  IMPLEMENT(get_unique_connection_name);
+
+  /* IMPLEMENT(connecting) */
+  IMPLEMENT (connected);
+  IMPLEMENT(disconnected);
+  IMPLEMENT(shut_down);
+  IMPLEMENT(start_connecting);
+
+  klass->interfaces_always_present =
+    (char const **)ring_connection_interfaces_always_present;
+  IMPLEMENT(create_channel_managers);
+#undef IMPLEMENT
+}
+
+/* ---------------------------------------------------------------------- */
+/* RingConnection interface */
+
+gchar **
+ring_connection_dup_implemented_interfaces (void)
+{
+  return g_strdupv ((GStrv)ring_connection_interfaces_always_present);
 }
 
 char const *