libmmanager/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, MMModulePrivate))
  31
  32 G_DEFINE_TYPE (MMModule, mm_module, G_TYPE_TYPE_MODULE);
  33
  34 struct _MMModulePrivate {
  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 (MMModulePrivate));
  71 }
  72
  73 static void
  74 mm_module_init (MMModule *module)
  75 {
  76   MMModulePrivate *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   MMModulePrivate *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   MMModulePrivate *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 /**
 178  * mm_module_load_file:
 179  * @path: the path of the module to load.
 180  *
 181  * Creates a #MMModule object for the specified path.
 182  *
 183  * Return value: a #MMModule object or %NULL.
 184  */
 185
 186 MMModule *
 187 mm_module_load_file (const char *path)
 188 {
 189   MMModule *module;
 190
 191   module = g_object_new (MM_TYPE_MODULE, NULL);
 192   module->details->filename = g_strdup (path);
 193
 194   if (g_type_module_use (G_TYPE_MODULE (module))) {
 195     add_module_objects (module);
 196     g_type_module_unuse (G_TYPE_MODULE (module));
 197     return module;
 198   } else {
 199     g_object_unref (module);
 200     return NULL;
 201   }
 202 }
 203
 204 /**
 205  * mm_module_get_application_provider:
 206  * @module: a #MMModule.
 207  *
 208  * Gets the #MMApplicationProvider for the module.
 209  *
 210  * Return value: a #MMApplicationProvider object or %NULL.
 211  */
 212
 213 MMApplicationProvider *
 214 mm_module_get_application_provider (MMModule *module)
 215 {
 216   g_return_val_if_fail (module != NULL, NULL);
 217
 218   return module->details->app_provider;
 219 }
 220
 221 /**
 222  * mm_module_get_category_provider:
 223  * @module: a #MMModule.
 224  *
 225  * Gets the #MMCategoryProvider for the module.
 226  *
 227  * Return value: a #MMCategoryProvider object or %NULL.
 228  */
 229
 230 MMCategoryProvider *
 231 mm_module_get_category_provider (MMModule *module)
 232 {
 233   g_return_val_if_fail (module != NULL, NULL);
 234
 235   return module->details->category_provider;
 236 }
 237
 238 /**
 239  * mm_module_get_hit_collection_provider:
 240  * @module: a #MMModule.
 241  *
 242  * Gets the #MMHitCollectionProvider for the module.
 243  *
 244  * Return value: a #MMHitCollectionProvider object or %NULL.
 245  */
 246
 247 MMHitCollectionProvider *
 248 mm_module_get_hit_collection_provider (MMModule *module)
 249 {
 250   g_return_val_if_fail (module != NULL, NULL);
 251
 252   return module->details->collection_provider;
 253 }
 254
 255 /**
 256  * mm_module_get_name:
 257  * @module: a #MMModule.
 258  *
 259  * Gets the name of the module.
 260  *
 261  * Return value: a string containing the module name.
 262  */
 263
 264 char *
 265 mm_module_get_name (MMModule *module)
 266 {
 267   char *name;
 268
 269   module->get_name (&name);
 270
 271   return name;
 272 }