libfreesmartphone/freesmartphone-network.c

   1 /*
   2  *  freesmartphone-network.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 #include "freesmartphone-internal.h"
  28 #include "freesmartphone-network.h"
  29 #include "freesmartphone-network-binding.h"
  30 #include "fso-marshallers.h"
  31
  32 #define FSO_NETWORK_STATUS_SIGNAL_NAME "Status"
  33 #define FSO_SUBSCRIBER_NUMBERS_SIGNAL_NAME "SubscriberNumbers"
  34
  35
  36 /**
  37 * @brief Initializes network interface, it is called automatically
  38 * when necessary
  39 *
  40 * @param fs pointer to freesmartphone struct
  41 */
  42 void fso_gsm_network_init(FreeSmartphone *fs)
  43 {
  44         g_debug("%s", __func__);
  45
  46         /* Status */
  47         dbus_g_object_register_marshaller (fso_marshaller_VOID__STRING_STRING_INT,
  48                                            G_TYPE_NONE,
  49                                            G_TYPE_STRING,
  50                                            G_TYPE_STRING,
  51                                            G_TYPE_INT,
  52                                            G_TYPE_INVALID);
  53 }
  54
  55 /**
  56 * @brief Reply function to fso_gsm_network_register function call
  57 *
  58 * @param proxy dbus proxy used to call fso_gsm_network_register function
  59 * @param error pointer to error struct
  60 * @param userdata userdata passed when fso_gsm_network_register function was
  61 * called
  62 */
  63 static
  64 void fso_gsm_network_register_reply(DBusGProxy *proxy,
  65                                     GError *error,
  66                                     gpointer userdata)
  67 {
  68         g_debug("%s", __func__);
  69         ReplyData *reply = (ReplyData*)userdata;
  70         FSGSMNetworkReplyFunc reply_cb = (FSGSMNetworkReplyFunc)reply->cb;
  71         gpointer data = reply->data;
  72         fso_reply_data_free(reply);
  73         reply_cb(error,data);
  74 }
  75
  76
  77 /**
  78 * @brief Registers to network
  79 *
  80 * @param fs pointer to freesmartphone struct
  81 * @param cb callback function to call when registration command has finished
  82 * @param userdata user data
  83 * @return true if function was succesfully executed
  84 */
  85 gboolean fso_gsm_network_register(FreeSmartphone *fs,
  86                                   FSGSMNetworkReplyFunc cb,
  87                                   gpointer userdata)
  88 {
  89         g_return_val_if_fail(fs, FALSE);
  90         g_debug("%s", __func__);
  91         ReplyData *replydata = fso_prepare_method(fs,
  92                                                   G_CALLBACK(cb),
  93                                                   userdata,
  94                                                   FSO_NETWORK);
  95         if ( !replydata )
  96                 return FALSE;
  97
  98         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
  99
 100         org_freesmartphone_GSM_Network_register_async(proxy,
 101                                                       &fso_gsm_network_register_reply,
 102                                                       (gpointer)replydata);
 103         return TRUE;
 104 }
 105
 106 /**
 107 * @brief Reply function to get status
 108 *
 109 * @param proxy dbus proxy used to call fso_gsm_network_get_status function
 110 * @param error pointer to error struct
 111 * @param userdata userdata passed when fso_gsm_network_get_status function was
 112 * called
 113 */
 114 static
 115 void fso_gsm_network_get_status_reply(DBusGProxy *proxy,
 116                                       GHashTable *status,
 117                                       GError *error,
 118                                       gpointer userdata)
 119 {
 120         g_debug("%s", __func__);
 121         ReplyData *reply = (ReplyData*)userdata;
 122         FSGSMNetworkGetStatusReplyFunc reply_cb = (FSGSMNetworkGetStatusReplyFunc)reply->cb;
 123         gpointer data = reply->data;
 124         fso_reply_data_free(reply);
 125         reply_cb(status,error,data);
 126 }
 127
 128
 129 /**
 130 * @brief Gets network status
 131 *
 132 * @param fs pointer to freesmartphone struct
 133 * @param cb callback function to call when get status command has finished
 134 * @param userdata user data
 135 * @return true if function was succesfully executed
 136 */
 137 gboolean fso_gsm_network_get_status(FreeSmartphone *fs,
 138                                     FSGSMNetworkGetStatusReplyFunc cb,
 139                                     gpointer userdata)
 140 {
 141         g_return_val_if_fail(fs, FALSE);
 142         g_debug("%s", __func__);
 143         ReplyData *replydata = fso_prepare_method(fs,
 144                                                   G_CALLBACK(cb),
 145                                                   userdata,
 146                                                   FSO_NETWORK);
 147         if ( !replydata )
 148                 return FALSE;
 149
 150         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 151
 152         org_freesmartphone_GSM_Network_get_status_async(proxy,
 153                                                         &fso_gsm_network_get_status_reply,
 154                                                         (gpointer)replydata);
 155         return TRUE;
 156 }
 157
 158
 159
 160 /**
 161 * @brief Reply function to get status
 162 *
 163 * @param proxy dbus proxy used to call fso_gsm_network_list_providers function
 164 * @param error pointer to error struct
 165 * @param userdata userdata passed when fso_gsm_network_list_providers function
 166 * was called
 167 */
 168 static
 169 void fso_gsm_network_list_providers_reply(DBusGProxy *proxy,
 170                                           GPtrArray *providers,
 171                                           GError *error,
 172                                           gpointer userdata)
 173 {
 174         g_debug("%s", __func__);
 175         ReplyData *reply = (ReplyData*)userdata;
 176         FSGSMNetworkListProvidersReplyFunc reply_cb = (FSGSMNetworkListProvidersReplyFunc)reply->cb;
 177         gpointer data = reply->data;
 178         fso_reply_data_free(reply);
 179         reply_cb(providers,error,data);
 180 }
 181
 182
 183 /**
 184 * @brief Lists available network providers
 185 *
 186 * @param fs pointer to freesmartphone struct
 187 * @param cb callback function to call when list providers command has finished
 188 * @param userdata user data
 189 * @return true if function was succesfully executed
 190 */
 191 gboolean fso_gsm_network_list_providers(FreeSmartphone *fs,
 192                                         FSGSMNetworkListProvidersReplyFunc cb,
 193                                         gpointer userdata)
 194 {
 195         g_return_val_if_fail(fs, FALSE);
 196         g_debug("%s", __func__);
 197         ReplyData *replydata = fso_prepare_method(fs,
 198                                                   G_CALLBACK(cb),
 199                                                   userdata,
 200                                                   FSO_NETWORK);
 201         if ( !replydata )
 202                 return FALSE;
 203
 204         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 205
 206         org_freesmartphone_GSM_Network_list_providers_async(proxy,
 207                                                             &fso_gsm_network_list_providers_reply,
 208                                                             (gpointer)replydata);
 209         return TRUE;
 210 }
 211
 212 /**
 213 * @brief Reply function to get status
 214 *
 215 * @param proxy dbus proxy used to call fso_gsm_network_register_with_provider
 216 * function
 217 * @param error pointer to error struct
 218 * @param userdata userdata passed when fso_gsm_network_register_with_provider
 219 * function was called
 220 */
 221 static
 222 void fso_gsm_network_register_with_provider_reply(DBusGProxy *proxy,
 223                                                   GError *error,
 224                                                   gpointer userdata)
 225 {
 226         g_debug("%s", __func__);
 227         ReplyData *reply = (ReplyData*)userdata;
 228         FSGSMNetworkReplyFunc reply_cb = (FSGSMNetworkReplyFunc)reply->cb;
 229         gpointer data = reply->data;
 230         fso_reply_data_free(reply);
 231         reply_cb(error,data);
 232 }
 233
 234
 235 /**
 236 * @brief Lists available network providers
 237 *
 238 * @param fs pointer to freesmartphone struct
 239 * @param cb callback function to call when list providers command has finished
 240 * @param userdata user data
 241 * @return true if function was succesfully executed
 242 */
 243 gboolean fso_gsm_network_register_with_provider(FreeSmartphone *fs,
 244                                                 gint operator_code,
 245                                                 FSGSMNetworkReplyFunc cb,
 246                                                 gpointer userdata)
 247 {
 248         g_return_val_if_fail(fs, FALSE);
 249         g_debug("%s", __func__);
 250         ReplyData *replydata = fso_prepare_method(fs,
 251                                                   G_CALLBACK(cb),
 252                                                   userdata,
 253                                                   FSO_NETWORK);
 254         if ( !replydata )
 255                 return FALSE;
 256
 257         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 258
 259         org_freesmartphone_GSM_Network_register_with_provider_async(proxy,
 260                                                                     operator_code,
 261                                                                     &fso_gsm_network_register_with_provider_reply,
 262                                                                     (gpointer)replydata);
 263         return TRUE;
 264 }
 265
 266 ///**
 267 //* @brief Reply to get subscriber numbers function
 268 //*
 269 //* @param proxy dbus proxy used to call fso_gsm_network_get_subscriber_numbers
 270 //* function
 271 //* @param numbers subscriber numbers
 272 //* @param error pointer to error struct
 273 //* @param userdata userdata passed when fso_gsm_network_get_subscriber_numbers
 274 //* function was called
 275 //*/
 276 //static
 277 //void fso_gsm_network_get_subscriber_numbers_reply(DBusGProxy *proxy,
 278 //                                                  gchar **numbers,
 279 //                                                  GError *error,
 280 //                                                  gpointer userdata)
 281 //{
 282 //        g_debug("%s", __func__);
 283 //        ReplyData *reply = (ReplyData*)userdata;
 284 //        FSGSMNetworkGetSubscriberNumbersReplyFunc reply_cb = (FSGSMNetworkGetSubscriberNumbersReplyFunc)reply->cb;
 285 //        gpointer data = reply->data;
 286 //        fso_reply_data_free(reply);
 287 //        reply_cb(numbers,error,data);
 288 //}
 289
 290
 291 ///**
 292 //* @brief Get subscriber numbers
 293 //*
 294 //* @param fs pointer to freesmartphone struct
 295 //* @param cb callback function to call when the command has finished
 296 //* @param userdata user data
 297 //* @return true if function was succesfully executed
 298 //*/
 299 //gboolean fso_gsm_network_get_subscriber_numbers(FreeSmartphone *fs,
 300 //                                                FSGSMNetworkGetSubscriberNumbersReplyFunc cb,
 301 //                                                gpointer userdata)
 302 //{
 303 //        g_return_val_if_fail(fs, FALSE);
 304 //        g_debug("%s", __func__);
 305 //        ReplyData *replydata = fso_prepare_method(fs,
 306 //                                                  G_CALLBACK(cb),
 307 //                                                  userdata,
 308 //                                                  FSO_NETWORK);
 309 //        if ( !replydata )
 310 //                return FALSE;
 311 //
 312 //        DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 313 //
 314 //        org_freesmartphone_GSM_Network_get_subscriber_numbers_async(proxy,
 315 //                                                                    &fso_gsm_network_get_subscriber_numbers_reply,
 316 //                                                                    (gpointer)replydata);
 317 //        return TRUE;
 318 //}
 319
 320 /**
 321 * @brief Reply function to get country code
 322 *
 323 * @param proxy dbus proxy used to call fso_gsm_network_get_country_code function
 324 * @param error pointer to error struct
 325 * @param userdata userdata passed when fso_gsm_network_get_country_code function
 326 * was called
 327 */
 328 static
 329 void fso_gsm_network_get_country_code_reply(DBusGProxy *proxy,
 330                                             gchar *dial_code,
 331                                             GError *error,
 332                                             gpointer userdata)
 333 {
 334         g_debug("%s", __func__);
 335         ReplyData *reply = (ReplyData*)userdata;
 336         FSGSMNetworkGetCountryCodeReplyFunc reply_cb = (FSGSMNetworkGetCountryCodeReplyFunc)reply->cb;
 337         gpointer data = reply->data;
 338         fso_reply_data_free(reply);
 339         reply_cb(dial_code,error,data);
 340 }
 341
 342
 343 /**
 344 * @brief Gets country code
 345 *
 346 * @param fs pointer to freesmartphone struct
 347 * @param cb callback function to call when the command has finished
 348 * @param userdata user data
 349 * @return true if function was succesfully executed
 350 */
 351 gboolean fso_gsm_network_get_country_code(FreeSmartphone *fs,
 352                                           FSGSMNetworkGetCountryCodeReplyFunc cb,
 353                                           gpointer userdata)
 354 {
 355         g_return_val_if_fail(fs, FALSE);
 356         g_debug("%s", __func__);
 357         ReplyData *replydata = fso_prepare_method(fs,
 358                                                   G_CALLBACK(cb),
 359                                                   userdata,
 360                                                   FSO_NETWORK);
 361         if ( !replydata )
 362                 return FALSE;
 363
 364         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 365
 366         org_freesmartphone_GSM_Network_get_country_code_async(proxy,
 367                                                               &fso_gsm_network_get_country_code_reply,
 368                                                               (gpointer)replydata);
 369         return TRUE;
 370 }
 371
 372
 373
 374 /**
 375 * @brief Handler to network status signal
 376 * Calls all registered callbacks.
 377 *
 378 * @param proxy proxy to the connection that signal was sent through
 379 * @param provider_name provider's name
 380 * @param status network status
 381 * @param strength signal strength
 382 * @param data user data
 383 */
 384 static
 385 void fso_gsm_network_status_handler(DBusGProxy *proxy,
 386                                     GHashTable *status,
 387                                     gpointer data)
 388 {
 389         g_debug("%s", __func__);
 390         FreeSmartphone *fs = (FreeSmartphone*)data;
 391         g_return_if_fail(fs);
 392         GList *list = fso_get_signal_handler(fs,FSO_SIGNAL_NETWORK_STATUS);
 393
 394         while ( list ) {
 395                 ReplyData *rd = (ReplyData*)list->data;
 396                 FSGSMNetworkStatusSignalFunc status_cb = (FSGSMNetworkStatusSignalFunc)rd->cb;
 397                 status_cb (status, rd->data);
 398                 list = g_list_next(list);
 399         }
 400 }
 401
 402
 403 /**
 404 * @brief Adds a callback to network status signal
 405 *
 406 * @param fs pointer to freesmartphone struct
 407 * @param cb callback function to call when signal is received
 408 * @param userdata user data passed along with callback
 409 * @return true if callback was succesfully added
 410 */
 411 gboolean fso_gsm_network_status_signal(FreeSmartphone *fs,
 412                                        FSGSMNetworkStatusSignalFunc cb,
 413                                        gpointer userdata)
 414 {
 415         g_return_val_if_fail(fs, FALSE);
 416         g_debug("%s", __func__);
 417
 418         ReplyData *replydata = fso_prepare_method(fs,
 419                                                   G_CALLBACK(cb),
 420                                                   userdata,
 421                                                   FSO_NETWORK);
 422         if ( !replydata )
 423                 return FALSE;
 424
 425         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 426
 427         if ( fso_append_data_to_signal_handler(fs,
 428                                                FSO_SIGNAL_NETWORK_STATUS,
 429                                                replydata) ) {
 430                 dbus_g_proxy_add_signal(proxy,
 431                                         FSO_NETWORK_STATUS_SIGNAL_NAME,
 432                                         dbus_g_type_get_map ("GHashTable", \
 433                                                              G_TYPE_STRING, G_TYPE_VALUE),
 434                                         G_TYPE_INVALID);
 435                 dbus_g_proxy_connect_signal (proxy, FSO_NETWORK_STATUS_SIGNAL_NAME,
 436                                              G_CALLBACK(fso_gsm_network_status_handler),
 437                                              fs, NULL);
 438         }
 439
 440         return TRUE;
 441 }
 442
 443 /**
 444 * @brief Removes callback from network status signal
 445 *
 446 * @param fs pointer to freesmartphone struct
 447 * @param cb callback function to remove
 448 * @param userdata userdata assosicated with callback
 449 * @return true if callback was removed
 450 */
 451 gboolean fso_gsm_network_status_signal_remove(FreeSmartphone *fs,
 452                                            FSGSMNetworkStatusSignalFunc cb,
 453                                            gpointer userdata)
 454 {
 455         g_return_val_if_fail(fs, FALSE);
 456         g_debug("%s", __func__);
 457
 458
 459         return fso_signal_remove(fs,
 460                                  FSO_NETWORK,
 461                                  FSO_NETWORK_STATUS_SIGNAL_NAME,
 462                                  FSO_SIGNAL_NETWORK_STATUS,
 463                                  G_CALLBACK(fso_gsm_network_status_handler),
 464                                  (gpointer)fs,
 465                                  G_CALLBACK(cb),
 466                                  userdata);
 467 }
 468
 469 /**
 470 * @brief Handler to network status signal
 471 * Calls all registered callbacks.
 472 *
 473 * @param proxy proxy to the connection that signal was sent through
 474 * @param provider_name provider's name
 475 * @param status network status
 476 * @param strength signal strength
 477 * @param data user data
 478 */
 479 static
 480 void fso_gsm_network_subscriber_numbers_signal_handler(DBusGProxy *proxy,
 481                                     gchar **numbers,
 482                                     gpointer data)
 483 {
 484         g_debug("%s", __func__);
 485         FreeSmartphone *fs = (FreeSmartphone*)data;
 486         g_return_if_fail(fs);
 487         GList *list = fso_get_signal_handler(fs,FSO_SIGNAL_SUBSCRIBER_NUMBERS);
 488
 489         while ( list ) {
 490                 ReplyData *rd = (ReplyData*)list->data;
 491                 FSGSMNetworkSubscriberNumbersSignalFunc status_cb = (FSGSMNetworkSubscriberNumbersSignalFunc)rd->cb;
 492                 status_cb (numbers,rd->data);
 493                 list = g_list_next(list);
 494         }
 495 }
 496
 497
 498 /**
 499 * @brief Adds a callback to subscriber numbers signal
 500 *
 501 * @param fs pointer to freesmartphone struct
 502 * @param cb callback function to call when signal is received
 503 * @param userdata user data passed along with callback
 504 * @return true if callback was succesfully added
 505 */
 506 gboolean fso_gsm_network_subscriber_numbers_signal(FreeSmartphone *fs,
 507                                        FSGSMNetworkSubscriberNumbersSignalFunc cb,
 508                                        gpointer userdata)
 509 {
 510         g_return_val_if_fail(fs, FALSE);
 511         g_debug("%s", __func__);
 512
 513         ReplyData *replydata = fso_prepare_method(fs,
 514                                                   G_CALLBACK(cb),
 515                                                   userdata,
 516                                                   FSO_NETWORK);
 517         if ( !replydata )
 518                 return FALSE;
 519
 520         DBusGProxy *proxy = fso_get_proxy(fs,FSO_NETWORK);
 521
 522         if ( fso_append_data_to_signal_handler(fs,
 523                                                FSO_SIGNAL_SUBSCRIBER_NUMBERS,
 524                                                replydata) ) {
 525                 dbus_g_proxy_add_signal(proxy,
 526                                         FSO_SUBSCRIBER_NUMBERS_SIGNAL_NAME,
 527                                         G_TYPE_STRING,
 528                                         G_TYPE_STRING,
 529                                         G_TYPE_INT,
 530                                         G_TYPE_INVALID);
 531                 dbus_g_proxy_connect_signal (proxy, FSO_SUBSCRIBER_NUMBERS_SIGNAL_NAME,
 532                                              G_CALLBACK(fso_gsm_network_subscriber_numbers_signal_handler),
 533                                              fs, NULL);
 534         }
 535
 536         return TRUE;
 537 }
 538
 539 /**
 540 * @brief Removes callback from subscriber numbers signal
 541 *
 542 * @param fs pointer to freesmartphone struct
 543 * @param cb callback function to remove
 544 * @param userdata userdata assosicated with callback
 545 * @return true if callback was removed
 546 */
 547 gboolean fso_gsm_network_subscriber_numbers_signal_remove(FreeSmartphone *fs,
 548                                            FSGSMNetworkSubscriberNumbersSignalFunc cb,
 549                                            gpointer userdata)
 550 {
 551         g_return_val_if_fail(fs, FALSE);
 552         g_debug("%s", __func__);
 553
 554
 555         return fso_signal_remove(fs,
 556                                  FSO_NETWORK,
 557                                  FSO_SUBSCRIBER_NUMBERS_SIGNAL_NAME,
 558                                  FSO_SIGNAL_SUBSCRIBER_NUMBERS,
 559                                  G_CALLBACK(fso_gsm_network_subscriber_numbers_signal_handler),
 560                                  (gpointer)fs,
 561                                  G_CALLBACK(cb),
 562                                  userdata);
 563 }