vcs.maemo.org Git - maevies/blob - src/mvs-minfo-provider-service.c

   1 /*
   2  * mvs-minfo-provider-service.c
   3  *
   4  * This file is part of maevies
   5  * Copyright (C) 2010 Simón Pena <spenap@gmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  */
  18
  19 #include <dbus/dbus-glib-bindings.h>
  20
  21 #include "mvs-minfo-provider-service.h"
  22 #include "mvs-minfo-provider.h"
  23 #include "mvs-tmdb-movie-service.h"
  24 #include "mvs-tmdb-movie.h"
  25
  26 #define MINFO_PROVIDER_SERVICE_OBJECT_PATH "/MInfoProvider"
  27 #define MINFO_PROVIDER_SERVICE_NAME "com.simonpena.maevies.minfoprovider"
  28
  29 G_DEFINE_TYPE (MvsMInfoProviderService, mvs_minfo_provider_service, G_TYPE_OBJECT)
  30
  31 enum {
  32         PROP_0,
  33         PROP_DBUSGCONN,
  34 };
  35
  36 enum {
  37         RESPONSE_RECEIVED,
  38         LAST_SIGNAL
  39 };
  40
  41 static guint
  42 mvs_minfo_provider_service_signals[LAST_SIGNAL] = { 0 };
  43
  44 #define GET_PRIVATE(o) \
  45         (G_TYPE_INSTANCE_GET_PRIVATE ((o), MVS_TYPE_MINFO_PROVIDER_SERVICE, MvsMInfoProviderServicePrivate))
  46
  47 struct _MvsMInfoProviderServicePrivate {
  48         MvsMInfoProvider *minfo_provider;
  49         DBusGConnection *connection;
  50         guint search_id;
  51 };
  52
  53 gboolean
  54 mvs_minfo_provider_service_query (MvsMInfoProviderService *self,
  55                                   MvsService service,
  56                                   const gchar *query,
  57                                   GError **error)
  58 {
  59         return mvs_minfo_provider_query (self->priv->minfo_provider,
  60                         service, query);
  61 }
  62
  63 #include "mvs-minfo-provider-service-glue.h"
  64
  65 static void
  66 response_received_cb (MvsMInfoProvider *provider, GList *list,
  67                       gpointer user_data)
  68 {
  69         MvsMInfoProviderService *self = MVS_MINFO_PROVIDER_SERVICE (user_data);
  70         MvsTMDBMovieService *movie = NULL;
  71         GError *error = NULL;
  72         GList *iter = NULL;
  73         gchar  **object_paths= g_new0 (gchar*, g_list_length (list) + 1);
  74         guint i = 0;
  75
  76         for (iter = list; iter; iter = iter->next) {
  77                 if (MVS_IS_TMDB_MOVIE (iter->data)) {
  78                         MvsTmdbMovie *tmdb_movie = MVS_TMDB_MOVIE (iter->data);
  79                         gchar *uid_suffix = g_strdup_printf ("%d_%s",
  80                                         self->priv->search_id,
  81                                         mvs_tmdb_movie_get_id (tmdb_movie));
  82
  83                         mvs_tmdb_movie_print (tmdb_movie);
  84                         movie = mvs_tmdb_movie_service_new (self->priv->connection,
  85                                         tmdb_movie, uid_suffix);
  86                         object_paths[i] = g_strdup_printf ("/TMDBMovie/%s",
  87                                         uid_suffix);
  88                         g_free (uid_suffix);
  89                 }
  90                 i++;
  91         }
  92         object_paths[i] = NULL;
  93
  94         g_signal_emit (self, mvs_minfo_provider_service_signals[RESPONSE_RECEIVED], 0, object_paths);
  95         g_strfreev (object_paths);
  96         self->priv->search_id++;
  97 }
  98
  99 static void
 100 setup_dbus (MvsMInfoProviderService *self)
 101 {
 102         DBusGProxy *proxy;
 103         guint request_name_result;
 104         GError *error = NULL;
 105
 106         proxy = dbus_g_proxy_new_for_name (self->priv->connection,
 107                                            DBUS_SERVICE_DBUS,
 108                                            DBUS_PATH_DBUS,
 109                                            DBUS_INTERFACE_DBUS);
 110
 111         if (!org_freedesktop_DBus_request_name (proxy,
 112                                                 MINFO_PROVIDER_SERVICE_NAME,
 113                                                 0, &request_name_result,
 114                                                 &error)) {
 115                 g_warning ("Unable to register service: %s", error->message);
 116                 g_error_free (error);
 117         }
 118
 119         dbus_g_connection_register_g_object (self->priv->connection,
 120                                              MINFO_PROVIDER_SERVICE_OBJECT_PATH,
 121                                              G_OBJECT (self));
 122
 123         g_object_unref (proxy);
 124 }
 125
 126 static void
 127 mvs_minfo_provider_service_set_property (GObject *object, guint property_id,
 128                                   const GValue *value, GParamSpec *pspec)
 129 {
 130         MvsMInfoProviderService *self = MVS_MINFO_PROVIDER_SERVICE (object);
 131
 132         switch (property_id) {
 133         case PROP_DBUSGCONN:
 134                 if (!self->priv->connection) {
 135                         DBusGConnection *tmp = g_value_get_pointer (value);
 136                         if (tmp) {
 137                                 self->priv->connection =
 138                                         dbus_g_connection_ref (tmp);
 139                                 setup_dbus (self);
 140                         }
 141                 }
 142                 g_assert (self->priv->connection);
 143                 break;
 144         default:
 145                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 146         }
 147 }
 148
 149 static void
 150 mvs_minfo_provider_service_finalize (GObject *object)
 151 {
 152         MvsMInfoProviderService *self = MVS_MINFO_PROVIDER_SERVICE (object);
 153
 154         if (self->priv->connection) {
 155                 dbus_g_connection_unref (self->priv->connection);
 156         }
 157         g_object_unref (self->priv->minfo_provider);
 158         G_OBJECT_CLASS (mvs_minfo_provider_service_parent_class)->finalize (object);
 159 }
 160
 161 static void
 162 mvs_minfo_provider_service_class_init (MvsMInfoProviderServiceClass *klass)
 163 {
 164         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 165
 166         g_type_class_add_private (klass, sizeof (MvsMInfoProviderServicePrivate));
 167
 168         object_class->set_property = mvs_minfo_provider_service_set_property;
 169         object_class->finalize = mvs_minfo_provider_service_finalize;
 170
 171         g_object_class_install_property
 172                 (object_class, PROP_DBUSGCONN,
 173                  g_param_spec_pointer ("connection", "DBusGConnection",
 174                                        "DBus GConnection",
 175                                        G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 176
 177          dbus_g_object_type_install_info (MVS_TYPE_MINFO_PROVIDER_SERVICE,
 178                                           &dbus_glib_mvs_minfo_provider_service_object_info);
 179
 180          mvs_minfo_provider_service_signals[RESPONSE_RECEIVED] =
 181                          g_signal_new ("response-received",
 182                          G_TYPE_FROM_CLASS (klass),
 183                          G_SIGNAL_RUN_LAST,
 184                          0,
 185                          NULL,
 186                          NULL,
 187                          g_cclosure_marshal_VOID__POINTER,
 188                          G_TYPE_NONE,
 189                          1,
 190                          G_TYPE_STRV,
 191                          NULL);
 192 }
 193
 194 static void
 195 mvs_minfo_provider_service_init (MvsMInfoProviderService *self)
 196 {
 197         self->priv = GET_PRIVATE (self);
 198         self->priv->minfo_provider = mvs_minfo_provider_new ();
 199         self->priv->connection = NULL;
 200         self->priv->search_id = 0;
 201
 202         g_signal_connect (self->priv->minfo_provider, "response-received",
 203                           G_CALLBACK (response_received_cb), self);
 204 }
 205
 206 MvsMInfoProviderService*
 207 mvs_minfo_provider_service_new (DBusGConnection *connection)
 208 {
 209         return g_object_new (MVS_TYPE_MINFO_PROVIDER_SERVICE,
 210                              "connection", connection, NULL);
 211 }