libfreesmartphone/freesmartphone.c

   1 /*
   2  *  freesmartphone.c
   3  *
   4  *  Copyright(C) 2008 Ixonos Plc
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Boston, MA 02111.
  19  */
  20
  21 /*
  22  * Written by
  23  *   Heikki Paajanen
  24  *   Vesa Pikki
  25  */
  26
  27 /**
  28  * @mainpage Libfreesmartphone
  29  *
  30  * \section intro Introduction
  31  *
  32  * This is the documentation of libfreesmartphone, a library to access
  33  * GSMD2's dbus methods conveniently.
  34  *
  35  *
  36  */
  37
  38 #include <dbus/dbus-glib.h>
  39 #include <glib.h>
  40 #include "freesmartphone.h"
  41 #include "freesmartphone-internal.h"
  42 #include "freesmartphone-call.h"
  43 #include "freesmartphone-sms.h"
  44
  45 static InterfaceDetails
  46 details[]
  47 = {
  48         {FSO_CALL,
  49                 "/org/freesmartphone/GSM/Call",
  50                 "org.freesmartphone.GSM.Call",
  51                 fso_gsm_call_init
  52         },
  53
  54         {FSO_DEVICE,
  55          "/org/freesmartphone/GSM/Device",
  56          "org.freesmartphone.GSM.Device",
  57          fso_gsm_device_init},
  58
  59         {FSO_NETWORK,
  60          "/org/freesmartphone/GSM/Network",
  61          "org.freesmartphone.GSM.Network",
  62          fso_gsm_network_init},
  63
  64         {FSO_PDP,
  65          "/org/freesmartphone/GSM/PDP",
  66          "org.freesmartphone.GSM.PDP",
  67          fso_gsm_pdp_init},
  68
  69         {FSO_SIM,
  70          "/org/freesmartphone/GSM/SIM",
  71          "org.freesmartphone.GSM.SIM",
  72          fso_gsm_sim_init},
  73
  74         {FSO_SMS,
  75          "/org/freesmartphone/GSM/SMS",
  76          "org.freesmartphone.GSM.SMS",
  77          fso_gsm_sms_init}
  78 };
  79
  80
  81 /**
  82  * Initialize libfreesmartphone library
  83  *
  84  *
  85  * @return Handle for the library or NULL if initialization fails
  86  */
  87 FreeSmartphone* fso_init()
  88 {
  89         g_debug("%s", __func__);
  90         g_type_init();
  91
  92         FreeSmartphone *fs = g_try_new0(FreeSmartphone, 1);
  93         if ( !fs ) {
  94                 g_warning("%s : Out of memory", __func__);
  95                 return NULL;
  96         }
  97         GError *error = NULL;
  98         fs->conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
  99         if ( !fs->conn || error) {
 100                 g_warning("%s : Failed connect to system bus: %s",
 101                           __func__, error->message);
 102                 g_error_free( error );
 103                 error = NULL;
 104                 fso_free(fs);
 105                 return NULL;
 106         }
 107
 108         fs->proxies = g_hash_table_new_full(g_int_hash,
 109                                             g_int_equal,
 110                                             NULL,
 111                                             g_object_unref);
 112
 113
 114         dbus_g_connection_ref (fs->conn);
 115
 116         return fs;
 117 }
 118 /**
 119  *
 120  *
 121  * @param fs
 122  */
 123 void fso_reply_data_free(ReplyData *rd)
 124 {
 125         g_free( rd );
 126 }
 127
 128 void fso_free_signal_handler(FreeSmartphone *fs,FSOSignal signal)
 129 {
 130     GList *list = fso_get_signal_handler(fs,signal);
 131
 132     while ( list ) {
 133                 fso_reply_data_free((ReplyData*)list->data);
 134                 list = g_list_next(list);
 135     }
 136
 137     list = fso_get_signal_handler(fs,signal);
 138
 139     if (list)
 140         g_list_free(list);
 141 }
 142
 143 void fso_free(FreeSmartphone *fs)
 144 {
 145         if ( !fs ) {
 146                 return;
 147         }
 148         if ( fs->conn ) {
 149                 dbus_g_connection_unref (fs->conn);
 150         }
 151
 152         g_hash_table_destroy(fs->proxies);
 153         fs->conn = NULL;
 154
 155         FSOSignal signal = FSO_SIGNAL_CALL_STATUS;
 156
 157         for(;signal<FSO_SIGNAL_LAST;signal++) {
 158             fso_free_signal_handler(fs,signal);
 159         }
 160
 161         g_free(fs);
 162 }
 163
 164
 165
 166
 167 ReplyData *fso_reply_data_new(GCallback cb,
 168                               gpointer data)
 169 {
 170         ReplyData *rd = g_try_new0(ReplyData, 1);
 171         if ( rd ) {
 172                 rd->cb = cb;
 173                 rd->data = data;
 174         }
 175         return rd;
 176 }
 177
 178
 179
 180 gboolean fso_signal_remove(FreeSmartphone *fs,
 181                            FSOInterface interface,
 182                            const gchar *signal_name,
 183                            FSOSignal signal,
 184                            GCallback signal_handler,
 185                            gpointer signal_handler_data,
 186                            GCallback usercb,
 187                            gpointer userdata)
 188 {
 189         GList *list = fso_get_signal_handler(fs,signal);
 190         DBusGProxy *proxy = fso_get_proxy(fs,interface);
 191
 192         ReplyData *match = NULL;
 193         while ( list ) {
 194                 ReplyData *rd = (ReplyData*)list->data;
 195                 if ( rd->cb == G_CALLBACK(usercb) && rd->data == userdata ) {
 196                         match= rd;
 197                         break;
 198                 }
 199                 list = g_list_next(list);
 200         }
 201         if ( match ) {
 202                 fs->signal_handlers[signal] = g_list_remove_all(fs->signal_handlers[signal], match);
 203                 if ( fs->signal_handlers[signal] == NULL) {
 204                         g_debug("%s : '%s'", __func__, signal_name);
 205                         dbus_g_proxy_disconnect_signal(proxy, signal_name,
 206                                                        G_CALLBACK(signal_handler),
 207                                                        signal_handler_data);
 208                 }
 209                 fso_reply_data_free( match );
 210         }
 211         return TRUE;
 212 }
 213
 214 /**
 215 * @brief Returns and ensures that specific interface's proxy exists,
 216 * creates it if necessary
 217 *
 218 * @param fs pointer to freesmartphone strucht
 219 * @param interface interface whose proxy to ensure
 220 * @return true if proxy exists, false if it couldn't be created
 221 */
 222 DBusGProxy *fso_get_proxy(FreeSmartphone *fs,FSOInterface interface)
 223 {
 224         g_assert(fs);
 225         g_assert(fs->proxies);
 226
 227         //Try to find the proxy
 228         DBusGProxy* proxy = g_hash_table_lookup(fs->proxies,
 229                                                 &details[interface].key);
 230
 231         if (!proxy) {
 232                 //If no proxy found, create
 233                 proxy = dbus_g_proxy_new_for_name(fs->conn,
 234                                                   FSO_GSM_SERVICE_NAME,
 235                                                   details[interface].path,
 236                                                   details[interface].interface);
 237
 238                 if (!proxy)
 239                         return NULL;
 240
 241                 //and add it
 242                 g_hash_table_insert(fs->proxies,
 243                                     &details[interface].key,
 244                                     proxy);
 245
 246                 if (details[interface].init)
 247                         details[interface].init(fs);
 248         }
 249
 250         return proxy;
 251 }
 252
 253 /**
 254 * @brief Appends replydata to signal handler
 255 *
 256 * @param fs pointer to freesmartphone struct
 257 * @param signal signal handler to append replydata to
 258 * @param replydata replydata to append
 259 * @return true if signal handler needs to be initialized
 260 */
 261 gboolean fso_append_data_to_signal_handler(FreeSmartphone *fs,
 262                                            FSOSignal signal,
 263                                            ReplyData *replydata)
 264 {
 265         g_return_val_if_fail(fs, FALSE);
 266         gboolean result = FALSE;
 267
 268         if (!fs->signal_handlers[signal])
 269                 result = TRUE;
 270
 271         fs->signal_handlers[signal] = g_list_append(fs->signal_handlers[signal],
 272                                                     replydata);
 273         return result;
 274 }
 275
 276 GList *fso_get_signal_handler(FreeSmartphone *fs, FSOSignal signal)
 277 {
 278         g_return_val_if_fail(fs, NULL);
 279         return fs->signal_handlers[signal];
 280 }
 281
 282
 283
 284
 285 /**
 286 * @brief Prepares replydata for a method call
 287 * Ensures that a proper proxy is present.
 288 *
 289 * @param fs pointer to freesmartphone data
 290 * @param cb Callback function
 291 * @param userdata user data
 292 * @param interface interface to which the method (we are preparing for) belongs
 293 * @return new replydata (that has to be freed) or null if failed
 294 */
 295 ReplyData *fso_prepare_method(FreeSmartphone *fs,
 296                               GCallback cb,
 297                               gpointer userdata,
 298                               FSOInterface interface)
 299 {
 300
 301         if ( !cb ) {
 302                 g_warning("%s : No callback function provided!", __func__);
 303                 return NULL;
 304         }
 305
 306         ReplyData *replydata = fso_reply_data_new(cb, userdata);
 307         if ( !replydata ) {
 308                 g_warning("%s : Out of memory", __func__);
 309                 return NULL;
 310         }
 311
 312
 313         DBusGProxy *proxy = fso_get_proxy(fs,interface);
 314
 315         if ( !proxy ) {
 316                 g_free( replydata );
 317                 return NULL;
 318         }
 319
 320         return replydata;
 321 }