Attachment 48825 Details for Bug 38978 – generic example of how an mcd transport plugin is formed

generic example of how an mcd transport plugin is formed

demo-transport-plugin.c (text/plain), 16.00 KB, created by Vivek Dasmohapatra on 2011-07-06 11:25:20 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Vivek Dasmohapatra

Created: 2011-07-06 11:25:20 UTC

Size: 16.00 KB

patch

obsolete

>/*
> * This file is not part of telepathy mission control
> * It is an example of an old-style McdTransport plugin
> *
> * Copyright Â© 2011 Collabora Ltd.
> *
> * This file is free software; you can redistribute it and/or
> * modify it under the terms of the GNU Lesser General Public License
> * version 2.1 as published by the Free Software Foundation.
> *
> * This library 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
> * Lesser General Public License for more details.
> *
> */
>
>#include <mission-control/mcd-plugin.h>
>#include <mission-control/mcd-account-compat.h>
>
>#define DEMO_TYPE_TRANSPORT_PLUGIN (demo_transport_plugin_get_type ())
>
>#define DEMO_TRANSPORT_PLUGIN(obj) \
>  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
>   DEMO_TYPE_TRANSPORT_PLUGIN, DemoTransportPlugin))
>
>#define DEMO_TRANSPORT_PLUGIN_CLASS(klass) \
>  (G_TYPE_CHECK_CLASS_CAST ((klass), \
>   DEMO_TYPE_TRANSPORT_PLUGIN, DemoTransportPluginClass))
>
>#define DEMO_IS_TRANSPORT_PLUGIN(obj) \
>  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DEMO_TYPE_TRANSPORT_PLUGIN))
>
>#define DEMO_IS_TRANSPORT_PLUGIN_CLASS(klass) \
>  (G_TYPE_CHECK_CLASS_TYPE ((klass), DEMO_TYPE_TRANSPORT_PLUGIN))
>
>#define DEMO_TRANSPORT_PLUGIN_GET_CLASS(obj) \
>  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
>   DEMO_TYPE_TRANSPORT_PLUGIN, DemoTransportPluginClass))
>
>static GType demo_transport_plugin_get_type (void) G_GNUC_CONST;
>
>typedef struct _DemoTransportPluginClass DemoTransportPluginClass;
>typedef struct _DemoTransportPlugin DemoTransportPlugin;
>
>struct _DemoTransportPluginClass
>{
>  GObjectClass parent_class;
>};
>
>/* this is the data structure associated with your plugin: it's up to you *
> * what you put in here, no one else gets to look inside:                 */
>struct _DemoTransportPlugin
>{
>  GObject parent_instance;
>
>  SomeThing *thing; /* some object or pointer representing our network
>                       transport framework */
>
>  GList *transports;
>  GList *connecting_accounts;
>  GHashTable *connections;
>  guint conn_count;
>};
>
>/* This is the per-transport data structure defined by the plugin    *
> * the plugin is responsible for constructing and managing this data *
> * structure, its internals are opaque to all other parts of MC      */
>struct _McdTransport
>{
>  /* put whatever data structures you need here: These are examples */
>  gchar *name;
>  McdTransportStatus status;
>};
>
>static void transport_plugin_init (McdTransportPluginIface *iface);
>
>static void account_connection_cb (McdAccount *account,
>    GHashTable *parameters,
>    gpointer userdata);
>
>static void connection_event(SomeThing *thing,
>    SomeData *data,
>    DemoTransportPlugin *plugin);
>
>static guint
>connections_after_event (DemoTransportPlugin *plugin,
>    const gchar *ap_name,
>    McdTransportStatus status);
>
>/* this symbol is looked for by the MCD plugin framework and
> * invoked to initialise the plugin: */
>void
>mcd_plugin_init (McdPlugin *plugin)
>{
>  McdTransportPlugin *transport_plugin;
>
>  transport_plugin = g_object_new (DEMO_TYPE_TRANSPORT_PLUGIN, NULL);
>
>  /* tell the MCD framework what kind of thingf we are: */
>  mcd_plugin_register_transport (plugin, transport_plugin);
>
>  /* accounts use this callback to ask us for a network to be brought up */
>  mcd_plugin_register_account_connection (plugin,
>      account_connection_cb,
>      MCD_ACCOUNT_CONNECTION_PRIORITY_TRANSPORT,
>      transport_plugin);
>}
>
>static const gchar *
>demo_transport_plugin_get_name (McdTransportPlugin *plugin)
>{
>  return "demo-transport-plugin";
>}
>
>static const GList *
>demo_transport_plugin_get_transports (McdTransportPlugin *plugin)
>{
>  return DEMO_TRANSPORT_PLUGIN (plugin)->transports;
>}
>
>/* we don't use account conditions any more, so it's best to no-op *
> * this particular plugin member:                                  */
>static gboolean
>demo_transport_plugin_check_conditions (McdTransportPlugin *plugin,
>    McdTransport *transport,
>    const GHashTable *conditions)
>{
>  return TRUE;
>}
>
>static const gchar *
>demo_transport_plugin_get_transport_name (McdTransportPlugin *plugin,
>    McdTransport *transport)
>{
>    return transport->name;
>}
>
>static McdTransportStatus
>demo_transport_plugin_get_transport_status (McdTransportPlugin *plugin,
>    McdTransport *transport)
>{
>    return transport->status;
>}
>
>static McdTransport *
>demo_transport_plugin_get_connected_transport (DemoTransportPlugin *plugin)
>{
>  GList *list;
>
>  for (list = plugin->transports; list != NULL; list = list->next)
>    {
>      McdTransport *tp = list->data;
>
>      if (tp->status == MCD_TRANSPORT_STATUS_CONNECTED)
>        return tp;
>    }
>
>    return NULL;
>}
>
>static void
>transport_plugin_init (McdTransportPluginIface *iface)
>{
>  iface->get_name = demo_transport_plugin_get_name;
>  iface->get_transports = demo_transport_plugin_get_transports;
>  iface->check_conditions = demo_transport_plugin_check_conditions;
>  iface->get_transport_name = demo_transport_plugin_get_transport_name;
>  iface->get_transport_status = demo_transport_plugin_get_transport_status;
>}
>
>static void
>demo_transport_free (McdTransport *transport)
>{
>  g_free (transport->name);
>  g_slice_free (McdTransport, transport);
>}
>
>static McdTransport *
>demo_transport_new ()
>{
>  McdTransport *transport = g_slice_new0(McdTransport);
>
>  return transport;
>}
>
>static void
>dispose (GObject *object)
>{
>  DemoTransportPlugin *plugin = DEMO_TRANSPORT_PLUGIN (object);
>
>  some_thing_free (plugin->thing);
>
>  G_OBJECT_CLASS (demo_transport_plugin_parent_class)->dispose (object);
>}
>
>static void
>finalize (GObject *object)
>{
>  DemoTransportPlugin *plugin = DEMO_TRANSPORT_PLUGIN (object);
>
>  g_list_foreach (plugin->transports, (GFunc) demo_transport_free, NULL);
>  g_list_free (plugin->transports);
>
>  G_OBJECT_CLASS (demo_transport_plugin_parent_class)->finalize (object);
>}
>
>static void
>demo_transport_plugin_init (DemoTransportPlugin *plugin)
>{
>    GError *error = NULL;
>
>    plugin->conn_count = 0;
>    plugin->connections =
>      g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
>
>    /* this is where we actually start talking to our network framework */
>    plugin->thing = some_thing_new ();
>
>    /* you should hook up to whatever signalling your transport framework *
>     * (NM, ConnMan, whatever) uses here: this is an example only:        */
>    g_signal_connect (plugin->thing, "network-up-down-sideways-event",
>        G_CALLBACK (connection_event), plugin);
>}
>
>static void
>demo_transport_plugin_class_init (DemoTransportPluginClass *klass)
>{
>    GObjectClass *object_class = G_OBJECT_CLASS (klass);
>
>    object_class->dispose = dispose;
>    object_class->finalize = finalize;
>}
>
>/* now the callbacks that duct tape everything together: */
>
>/* called by accounts when we tell them to _proceed: */
>/* NOTE: _proceed doesn't mean they wil succeed, it just means we tried
>   to get a network connection and got a reply: he replay can be "No"   */
>static void
>on_connection_process (McdAccount *account,
>    gboolean success,
>    DemoTransportPlugin *plugin)
>{
>    McdTransport *tp;
>    GHashTable *parameters;
>
>    /* our connection request completed we are no longer waiting: */
>    plugin->connecting_accounts =
>      g_list_remove (plugin->connecting_accounts, account);
>
>    /* don't need to be attached to this callback any more: */
>    g_signal_handlers_disconnect_by_func (account,
>        on_connection_process, plugin);
>
>    /* The data we stapled to the side of the account when it made its
>       initial connectivity request (demo_transport_plugin_notify_account) */
>    parameters = g_object_steal_data (G_OBJECT (account), DEMO_TRANSPORT_DATA);
>
>    tp = demo_transport_plugin_get_connected_transport (plugin);
>
>    if (parameters != NULL && success && tp != NULL)
>    {
>      /* do any extra tweaking of the account (keepalive params etc) here */
>    }
>
>    /* unref all the callback data */
>    g_hash_table_unref (parameters);
>    g_object_unref (account);
>}
>
>/* this tells our transport framework we would like a network connection *
> * and we also track which accounts ahave asked us for a connection here */
>static void
>demo_transport_plugin_notify_account (DemoTransportPlugin *plugin,
>    McdAccount *account,
>    GHashTable *parameters)
>{
>  /* NOTE: you might want to check:
>
>     mcd_account_connection_is_user_initiated ()
>
>     It tells you if this is a UI-triggered connection attempt or something
>     MC is doing behind the scenes without prompting from the user: In case
>     you care about such things (eg if your transport manager has an intrusive
>     UI that you don't want to spam the user with) */
>
>  MAKE_CONNECTION_REQUEST_CALL_TO_NM_CONNMAN_ETC_HERE (plugin);
>
>  /* the account was already on our list of connecting accounts */
>  if (g_list_find (plugin->connecting_accounts, account))
>    return;
>
>  /* hook our connection callback up to the account */
>  g_object_ref (account);
>  g_signal_connect (account, "connection-process",
>      G_CALLBACK (on_connection_process),
>      plugin);
>
>  /* remember that we were asked to connect for this account */
>  plugin->connecting_accounts =
>	g_list_prepend (plugin->connecting_accounts, account);
>
>  /* staple the connection data to the account for the callback we set above */
>  g_object_set_data_full (G_OBJECT (account),
>      DEMO_TRANSPORT_DATA,
>      g_hash_table_ref (parameters),
>      (GDestroyNotify) g_hash_table_unref);
>}
>
>
>/* this gets called when accounts attempt to go online and wants networking */
>static void
>account_connection_cb (McdAccount *account,
>    GHashTable *parameters,
>    gpointer userdata)
>{
>  DemoTransportPlugin *plugin = DEMO_TRANSPORT_PLUGIN (userdata);
>  const gchar *protocol = mcd_account_get_protocol_name (account);
>  McdTransport *tp;
>
>  /* we have to build in any exceptions here: the current framework
>     doesn't understand different connection types, so typically we
>     have to exclude non-IP protocols (eg telephony ones) here      */
>  if (protocol != NULL && (g_str_equal (protocol, "tel")))
>    {
>      mcd_account_connection_proceed (account, TRUE);
>      return;
>    }
>
>  /* so, we got this far - it's an account that needs IP: find a transport */
>  tp = demo_transport_plugin_get_connected_transport (plugin);
>
>  if (tp == NULL)
>    {
>      /* make a network connectivity requst here. We will get woken up     *
>       * when a connection becomes available (if we've done our job right) */
>      demo_transport_plugin_notify_account (plugin, account, parameters);
>    }
>    else
>    {
>      /* if we have any extra work to do, like tweaking keepalive parameters
>         based on the network type, we should do it here:  */
>
>      /* associate the account with the transport and tell it to proceed: */
>      mcd_account_connection_bind_transport (account, tp);
>      mcd_account_connection_proceed (account, TRUE);
>    }
>}
>
>/* this callback will have to be altered to fit the API that comes with
>   your particular variant of SomeThing: In our example it is connected
>   to the signal "network-up-down-sideways-event" fired by SomeThing.   */
>static void
>connection_event(SomeThing *thing, SomeData *data, DemoTransportPlugin *plugin);
>{
>    McdTransport *transport = NULL;
>    McdTransportStatus status;
>    GList *list;
>    const gchar *label;
>    gboolean can_route = FALSE;      /* do we have _any_ live connections? */
>    gboolean transient = FALSE;      /* is this a short-lived status?      */
>    gboolean this_can_route = FALSE; /* is _this_ event's connection live? */
>    const gchar *iap_name = some_thing_get_connection_name (data);
>
>    /* you will need to write _some_thing_connection_event_get_status
>       to map the status from this signal/whatever to McdTransportStatus */
>    status = _some_thing_connection_event_get_status (event);
>    can_route = connections_after_event (plugin, iap_name, status) > 0;
>
>    switch (status)
>    {
>      case MCD_TRANSPORT_STATUS_CONNECTED;
>        label = "MCD_TRANSPORT_STATUS_CONNECTED";
>        this_can_route = TRUE;
>        break;
>      case MCD_TRANSPORT_STATUS_DISCONNECTED;
>        label = "MCD_TRANSPORT_STATUS_DISCONNECTED";
>        break;
>      case MCD_TRANSPORT_STATUS_DISCONNECTING;
>        label = "MCD_TRANSPORT_STATUS_DISCONNECTING";
>        break;
>      case MCD_TRANSPORT_STATUS_CONNECTING;
>        label = "MCD_TRANSPORT_STATUS_CONNECTING";
>        transient = TRUE;
>        break;
>      default:
>        g_warning ("unsupported status %u", status);
>        return;
>    }
>
>    if (iap_name != NULL)
>    {
>      for (list = plugin->transports; list != NULL; list = list->next)
>        {
>          McdTransport *tp = list->data;
>
>          if (strcmp (tp->name, iap_name) == 0)
>            {
>              transport = tp;
>              break;
>            }
>        }
>
>      /* we have no record of this transport and this particular event *
>       * relates to a transport which is currently connected:          */
>      if (!transport && this_can_route)
>        {
>          /* create the transport */
>          transport = demo_transport_new();
>          transport->name = g_strdup (iap_name);
>          plugin->transports = g_list_prepend (plugin->transports, transport);
>        }
>
>      if (transport != NULL)
>        {
>          transport->status = status;
>          g_signal_emit_by_name (plugin, "status-changed", transport, status);
>        }
>    }
>
>    /* transient means we get another signal later, noop for */
>    if (transient)
>    {
>        g_debug ("Network in transient state %s, no action taken", label);
>    }
>    else
>    {
>        GList *next;
>        McdTransport *alt_transport = NULL;
>
>        if (!this_can_route)
>          {
>            alt_transport =
>              demo_transport_plugin_get_connected_transport (plugin);
>          }
>
>        for (list = plugin->connecting_accounts; list != NULL; list = next)
>          {
>            McdAccount *account = MCD_ACCOUNT (list->data);
>            /* you'll need to cobble together a suitable some_reason (): */
>            TpConnectionStatusReason why = some_reason (data);
>
>            g_debug ("connection of account %s can %sproceed",
>                mcd_account_get_unique_name (account),
>                status == can_route ? "" : "not ");
>
>            /* Since the mcd_account_connection_proceed() can emit
>             * "connection-process" which in turn can manipulate our list
>             * destrying the current element, we must save the pointer to the
>             * next one. */
>            next = list->next;
>
>            /* if this transport went online, bind waiting accounts to it: *
>             * if not, then it's kind of weird that we had any waiting     *
>             * accounts, but bind them to one of the live transports       */
>            if (this_can_route)
>              {
>                g_assert (transport != NULL);
>                mcd_account_connection_bind_transport (account, transport);
>              }
>            else if (alt_transport != NULL)
>              {
>                mcd_account_connection_bind_transport (account, alt_transport);
>              }
>
>            mcd_account_connection_proceed_with_reason (account, can_route, why);
>          }
>    }
>}
>
>/* track [dis]connects, so we can tell if we have working connection(s): */
>static guint
>connections_after_event (DemoTransportPlugin *plugin,
>    const gchar *ap_name,
>    McdTransportStatus status)
>{
>    gpointer stored = g_hash_table_lookup (plugin->connections, ap_name);
>    gboolean new_connection_status = status == MCD_TRANSPORT_STATUS_CONNECTED;
>    gboolean old_connection_status = stored == GUINT_TO_POINTER (TRUE);
>
>    /* this is where we keep count of whether the account went on or offline */
>    if (new_connection_status)
>      g_hash_table_insert (plugin->connections,
>          g_strdup (ap_name),
>          GUINT_TO_POINTER (TRUE));
>    else
>      g_hash_table_remove (plugin->connections, ap_name);
>
>    /* no change in status: nothing further to do here */
>    if (new_connection_status == old_connection_status)
>      return plugin->conn_count;
>
>    /* new_connection_status => we went online, otherwise we are offline.  *
>     * Also: it shouldn't be possible for count to go -ve: don't allow it: */
>    if (new_connection_status)
>      plugin->conn_count++;
>    else if (plugin->conn_count > 0)
>      plugin->conn_count--;
>
>    return plugin->conn_count;
>}

Actions: View

Attachments on bug 38978: 48825

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.