src/mm-module.c

   1 /* MManager - a Desktop wide manager for multimedia applications.
   2  *
   3  * Copyright (C) 2008 Cosimo Cecchi <cosimoc@gnome.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <glib.h>
  22 #include <glib-object.h>
  23 #include <gmodule.h>
  24 #include "mm-application-provider.h"
  25 #include "mm-category-provider.h"
  26 #include "mm-hit-collection-provider.h"
  27 #include "mm-module.h"
  28
  29 #define MM_MODULE_GET_PRIVATE(o) \
  30    (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_MODULE, MMModuleDetails))
  31
  32 G_DEFINE_TYPE (MMModule, mm_module, G_TYPE_TYPE_MODULE);
  33
  34 struct _MMModuleDetails {
  35   /* library objects */
  36   char    *filename;
  37   GModule *library;
  38
  39   /* providers implemented by the module */
  40   MMApplicationProvider   *app_provider;
  41   MMCategoryProvider      *category_provider;
  42   MMHitCollectionProvider *collection_provider;
  43
  44   /* name */
  45   char    *name;
  46 };
  47
  48
  49 static gboolean mm_module_load (GTypeModule *gtm);
  50 static void mm_module_unload (GTypeModule *gtm);
  51
  52 static void
  53 mm_module_finalize (GObject *o)
  54 {
  55   MMModule *module = MM_MODULE (o);
  56
  57   g_free (module->details->filename);
  58   G_OBJECT_CLASS (mm_module_parent_class)->finalize (o);
  59 }
  60
  61 static void
  62 mm_module_class_init (MMModuleClass *klass)
  63 {
  64   GTypeModuleClass *type_module_class = G_TYPE_MODULE_CLASS (klass);
  65
  66   type_module_class->load = mm_module_load;
  67   type_module_class->unload = mm_module_unload;
  68   G_OBJECT_CLASS (klass)->finalize = mm_module_finalize;
  69
  70   g_type_class_add_private (klass, sizeof (MMModuleDetails));
  71 }
  72
  73 static void
  74 mm_module_init (MMModule *module)
  75 {
  76   MMModuleDetails *details =  module->details = MM_MODULE_GET_PRIVATE (module);
  77
  78   details->filename = NULL;
  79   details->library = NULL;
  80   details->name = NULL;
  81 }
  82
  83 static gboolean
  84 mm_module_load (GTypeModule *gtm)
  85 {
  86   MMModule *module = MM_MODULE (gtm);
  87   MMModuleDetails *details = module->details;
  88   gpointer m_initialize, m_shutdown, m_get_types, m_get_name;
  89
  90   details->library = g_module_open (details->filename,
  91                                     G_MODULE_BIND_LAZY |
  92                                     G_MODULE_BIND_LOCAL);
  93   if (!details->library) {
  94     g_warning ("error while loading module %s: %s",
  95                details->filename, g_module_error ());
  96     return FALSE;
  97   }
  98
  99   if (!g_module_symbol (details->library,
 100                         "mm_module_initialize",
 101                         &m_initialize) ||
 102       !g_module_symbol (details->library,
 103                         "mm_module_shutdown",
 104                         &m_shutdown) ||
 105       !g_module_symbol (details->library,
 106                         "mm_module_get_types",
 107                         &m_get_types) ||
 108       !g_module_symbol (details->library,
 109                         "mm_module_get_name",
 110                         &m_get_name)) {
 111     g_warning ("Unable to resolve symbols inside the module %s: %s",
 112                details->filename, g_module_error ());
 113     g_module_close (details->library);
 114
 115     return FALSE;
 116   }
 117
 118   module->initialize = m_initialize;
 119   module->shutdown = m_shutdown;
 120   module->get_types = m_get_types;
 121   module->get_name = m_get_name;
 122
 123   module->initialize (gtm);
 124
 125   return TRUE;
 126 }
 127
 128 static void
 129 mm_module_unload (GTypeModule *gtm)
 130 {
 131         MMModule *module = MM_MODULE (gtm);
 132
 133   module->shutdown ();
 134
 135   g_module_close (module->details->library);
 136
 137   module->initialize = NULL;
 138   module->shutdown = NULL;
 139   module->get_types = NULL;
 140 }
 141
 142 static GObject *
 143 mm_module_create_provider (MMModule *module, GType type)
 144 {
 145   return g_object_new (type, NULL);
 146 }
 147
 148 static void
 149 mm_module_add_types (MMModule *module, GType *types)
 150 {
 151   /* types[0] implements MMApplicationProvider
 152    * types[1] implements MMCategoryProvider
 153    * types[2] implements MMHitCollectionProvider
 154    */
 155   MMModuleDetails *details = module->details;
 156
 157   details->app_provider =
 158     MM_APPLICATION_PROVIDER (mm_module_create_provider (module, types[0]));
 159   details->category_provider =
 160     MM_CATEGORY_PROVIDER (mm_module_create_provider (module, types[1]));
 161   details->collection_provider =
 162     MM_HIT_COLLECTION_PROVIDER (mm_module_create_provider (module, types[2]));
 163 }
 164
 165 static void
 166 add_module_objects (MMModule *module)
 167 {
 168   GType *gtypes;
 169
 170   module->get_types (&gtypes);
 171
 172   mm_module_add_types (module, gtypes);
 173 }
 174
 175 /* public methods */
 176
 177 MMModule *
 178 mm_module_load_file (const char *path)
 179 {
 180   MMModule *module;
 181
 182   module = g_object_new (MM_TYPE_MODULE, NULL);
 183   module->details->filename = g_strdup (path);
 184
 185   if (g_type_module_use (G_TYPE_MODULE (module))) {
 186     add_module_objects (module);
 187     g_type_module_unuse (G_TYPE_MODULE (module));
 188     return module;
 189   } else {
 190     g_object_unref (module);
 191     return NULL;
 192   }
 193 }
 194
 195 MMApplicationProvider *
 196 mm_module_get_application_provider (MMModule *m)
 197 {
 198   g_return_val_if_fail (m != NULL, NULL);
 199
 200   return m->details->app_provider;
 201 }
 202
 203 MMCategoryProvider *
 204 mm_module_get_category_provider (MMModule *m)
 205 {
 206   g_return_val_if_fail (m != NULL, NULL);
 207
 208   return m->details->category_provider;
 209 }
 210
 211 MMHitCollectionProvider *
 212 mm_module_get_hit_collection_provider (MMModule *m)
 213 {
 214   g_return_val_if_fail (m != NULL, NULL);
 215
 216   return m->details->collection_provider;
 217 }
 218
 219 char *
 220 mm_module_get_name (MMModule *m)
 221 {
 222   char *name;
 223
 224   m->get_name (&name);
 225
 226   return name;
 227 }