git.maemo.org Git - modest/blob - libmodest-dbus-client/libmodest-dbus-client.c

   1 /* Copyright (c) 2007, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "libmodest-dbus-client.h"
  31 #include <dbus_api/modest-dbus-api.h> /* For the API strings. */
  32
  33 //#define DBUS_API_SUBJECT_TO_CHANGE 1
  34 #include <dbus/dbus.h>
  35 #include <dbus/dbus-glib-lowlevel.h>
  36 #include <string.h>
  37
  38 /**
  39  * libmodest_dbus_client_send_mail:
  40  * @osso_context: a valid #osso_context_t object.
  41  * @to: The Recipients (From: line)
  42  * @cc: Recipients for carbon copies
  43  * @bcc: Recipients for blind carbon copies
  44  * @subject: Subject line
  45  * @body: The actual body of the mail to send
  46  * @attachments: Additional list of attachments
  47  *
  48  * This function will try to do a remote procedure call (rpc)
  49  * into modest (or start it if necessary) and open a composer
  50  * window with the supplied parameters prefilled.
  51  *
  52  * Return value: Whether or not the rpc call to modest
  53  * was successfull
  54  **/
  55
  56 gboolean
  57 libmodest_dbus_client_send_mail (osso_context_t *osso_context, const gchar *to, const gchar *cc,
  58         const gchar *bcc, const gchar* subject, const gchar* body, GSList *attachments)
  59 {
  60         osso_rpc_t retval;
  61         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
  62                    MODEST_DBUS_NAME,
  63                    MODEST_DBUS_METHOD_SEND_MAIL, &retval,
  64                    DBUS_TYPE_STRING, to,
  65                    DBUS_TYPE_STRING, cc,
  66                    DBUS_TYPE_STRING, bcc,
  67                    DBUS_TYPE_STRING, subject,
  68                    DBUS_TYPE_STRING, body,
  69                    DBUS_TYPE_INVALID);
  70
  71         if (ret != OSSO_OK) {
  72                 printf("debug: osso_rpc_run() failed.\n");
  73                 return FALSE;
  74         } else {
  75                 printf("debug: osso_rpc_run() succeeded.\n");
  76         }
  77
  78         osso_rpc_free_val(&retval);
  79
  80         return TRUE;
  81 }
  82
  83 gboolean
  84 libmodest_dbus_client_mail_to (osso_context_t *osso_context, const gchar *mailto_uri)
  85 {
  86         osso_rpc_t retval;
  87         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
  88                    MODEST_DBUS_NAME,
  89                    MODEST_DBUS_METHOD_MAIL_TO, &retval,
  90                    DBUS_TYPE_STRING, mailto_uri,
  91                    DBUS_TYPE_INVALID);
  92
  93         if (ret != OSSO_OK) {
  94                 printf("debug: osso_rpc_run() failed.\n");
  95                 return FALSE;
  96         } else {
  97                 printf("debug: osso_rpc_run() succeeded.\n");
  98         }
  99
 100         osso_rpc_free_val(&retval);
 101
 102         return TRUE;
 103 }
 104
 105 gboolean
 106 libmodest_dbus_client_compose_mail (osso_context_t *osso_context, const gchar *to, const gchar *cc,
 107         const gchar *bcc, const gchar* subject, const gchar* body, GSList *attachments)
 108 {
 109         osso_rpc_t retval;
 110         gchar *attachments_str = NULL;
 111         gchar *tmp = NULL;
 112         GSList *next = NULL;
 113
 114         attachments_str = g_strdup( (gchar *) attachments->data );
 115
 116         for (next = g_slist_next(attachments); next != NULL; next = g_slist_next(next))
 117         {
 118                 tmp = g_strconcat(attachments_str, ",", (gchar *) (next->data), NULL);
 119                 g_free(attachments_str);
 120                 attachments_str = tmp;
 121                 if (attachments_str == NULL) {
 122                         return OSSO_ERROR;
 123                 }
 124         }
 125
 126         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
 127                    MODEST_DBUS_NAME,
 128                    MODEST_DBUS_METHOD_COMPOSE_MAIL, &retval,
 129                    DBUS_TYPE_STRING, to,
 130                    DBUS_TYPE_STRING, cc,
 131                    DBUS_TYPE_STRING, bcc,
 132                    DBUS_TYPE_STRING, subject,
 133                    DBUS_TYPE_STRING, body,
 134                    DBUS_TYPE_STRING, attachments_str,
 135                    DBUS_TYPE_INVALID);
 136
 137         if (ret != OSSO_OK) {
 138                 printf("debug: osso_rpc_run() failed.\n");
 139                 return FALSE;
 140         } else {
 141                 printf("debug: osso_rpc_run() succeeded.\n");
 142         }
 143
 144         osso_rpc_free_val(&retval);
 145
 146         return TRUE;
 147 }
 148
 149 /**
 150  * libmodest_dbus_client_dopen_message:
 151  * @osso_context: a valid #osso_context_t object.
 152  * @msg_uri: A valid url to a mail
 153  *
 154  * This method will try to find the message supplied
 155  * by @msg_uri and open it for display if found.
 156  * It will use remote procedure calls (rpc) over
 157  * dbus to do so.
 158  *
 159  * Return value: TRUE on successs, FALSE on error
 160  **/
 161 gboolean
 162 libmodest_dbus_client_open_message (osso_context_t *osso_context, const gchar *mail_uri)
 163 {
 164         osso_rpc_t retval;
 165         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
 166                    MODEST_DBUS_NAME,
 167                    MODEST_DBUS_METHOD_OPEN_MESSAGE, &retval,
 168                    DBUS_TYPE_STRING, mail_uri,
 169                    DBUS_TYPE_INVALID);
 170
 171         if (ret != OSSO_OK) {
 172                 printf("debug: osso_rpc_run() failed.\n");
 173                 return FALSE;
 174         } else {
 175                 printf("debug: osso_rpc_run() succeeded.\n");
 176         }
 177
 178         osso_rpc_free_val(&retval);
 179
 180         return TRUE;
 181 }
 182
 183 gboolean
 184 libmodest_dbus_client_send_and_receive (osso_context_t *osso_context)
 185 {
 186         osso_rpc_t retval;
 187         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
 188                    MODEST_DBUS_NAME,
 189                    MODEST_DBUS_METHOD_SEND_RECEIVE, &retval,
 190                    DBUS_TYPE_INVALID);
 191
 192         if (ret != OSSO_OK) {
 193                 printf("debug: osso_rpc_run() failed.\n");
 194                 return FALSE;
 195         } else {
 196                 printf("debug: osso_rpc_run() succeeded.\n");
 197         }
 198
 199         osso_rpc_free_val(&retval);
 200
 201         return TRUE;
 202 }
 203
 204 gboolean
 205 libmodest_dbus_client_open_default_inbox (osso_context_t *osso_context)
 206 {
 207         osso_rpc_t retval;
 208         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
 209                    MODEST_DBUS_NAME,
 210                    MODEST_DBUS_METHOD_OPEN_DEFAULT_INBOX, &retval,
 211                    DBUS_TYPE_INVALID);
 212
 213         if (ret != OSSO_OK) {
 214                 printf("debug: osso_rpc_run() failed.\n");
 215                 return FALSE;
 216         } else {
 217                 printf("debug: osso_rpc_run() succeeded.\n");
 218         }
 219
 220         osso_rpc_free_val(&retval);
 221
 222         return TRUE;
 223 }
 224
 225 /**
 226  * libmodest_dbus_client_delete_message:
 227  * @osso_context: a valid #osso_context_t object.
 228  * @msg_uri: A valid url to a mail
 229  *
 230  * This method will try to find the message supplied
 231  * by @msg_uri and if found delete it. It will use
 232  * remote procedure calls (rpc) over dbus to do so.
 233  *
 234  * Return value: TRUE on successs, FALSE on error
 235  **/
 236 gboolean
 237 libmodest_dbus_client_delete_message (osso_context_t   *osso_ctx,
 238                                       const char       *msg_uri)
 239 {
 240         osso_rpc_t    retval;
 241         osso_return_t ret;
 242
 243         ret = osso_rpc_run_with_defaults (osso_ctx,
 244                                           MODEST_DBUS_NAME,
 245                                           MODEST_DBUS_METHOD_DELETE_MESSAGE, &retval,
 246                                           DBUS_TYPE_STRING, msg_uri,
 247                                           DBUS_TYPE_INVALID);
 248
 249         if (ret != OSSO_OK) {
 250                 g_debug ("debug: osso_rpc_run() failed.\n");
 251         } else {
 252                 g_debug ("debug: osso_rpc_run() succeeded.\n");
 253         }
 254
 255         osso_rpc_free_val (&retval);
 256
 257         return ret == OSSO_OK;
 258 }
 259
 260 void
 261 modest_search_hit_free (ModestSearchHit *hit)
 262 {
 263         g_free (hit->msgid);
 264         g_slice_free (ModestSearchHit, hit);
 265 }
 266
 267 void
 268 modest_search_hit_list_free (GList *hits)
 269 {
 270         GList *iter;
 271
 272         if (hits == NULL) {
 273                 return;
 274         }
 275
 276         for (iter = hits; iter; iter = iter->next) {
 277                 modest_search_hit_free ((ModestSearchHit *) iter->data);
 278         }
 279
 280         g_list_free (hits);
 281 }
 282
 283 static char *
 284 _dbus_iter_get_string_or_null (DBusMessageIter *iter)
 285 {
 286         const char *string;
 287         char       *ret;
 288
 289         dbus_message_iter_get_basic (iter, &string);
 290
 291         ret = NULL;
 292         if (string && strlen (string)) {
 293                 ret = g_strdup (string);
 294         }
 295
 296         return ret;
 297 }
 298
 299 static guint64
 300 _dbus_iter_get_uint64 (DBusMessageIter *iter)
 301 {
 302         dbus_uint64_t ui64v;
 303         guint64       ret;
 304
 305         ui64v = 0;
 306         dbus_message_iter_get_basic (iter, &ui64v);
 307
 308         ret = (guint64) ui64v;
 309
 310         return ret;
 311 }
 312
 313
 314 static gint64
 315 _dbus_iter_get_int64 (DBusMessageIter *iter)
 316 {
 317         dbus_int64_t i64v;
 318         gint64       ret;
 319
 320         i64v = 0;
 321         dbus_message_iter_get_basic (iter, &i64v);
 322
 323         ret = (gint64) i64v;
 324
 325         return ret;
 326 }
 327
 328 static gboolean
 329 _dbus_iter_get_boolean (DBusMessageIter *iter)
 330
 331 {
 332         dbus_bool_t  val;
 333         gboolean     ret;
 334
 335         val = FALSE;
 336         dbus_message_iter_get_basic (iter, &val);
 337
 338         ret = (gboolean) val;
 339
 340         return ret;
 341 }
 342
 343
 344 static ModestSearchHit *
 345 dbus_message_iter_get_search_hit (DBusMessageIter *parent)
 346 {
 347         ModestSearchHit *hit;
 348         DBusMessageIter  child;
 349         dbus_bool_t      res;
 350         int              arg_type;
 351         gboolean         error;
 352
 353         error = FALSE;
 354         hit = g_slice_new0 (ModestSearchHit);
 355
 356         arg_type = dbus_message_iter_get_arg_type (parent);
 357
 358         if (arg_type != 'r') {
 359                 return NULL;
 360         }
 361
 362         dbus_message_iter_recurse (parent, &child);
 363
 364         /* msgid  */
 365         arg_type = dbus_message_iter_get_arg_type (&child);
 366
 367         if (arg_type != DBUS_TYPE_STRING) {
 368                 error = TRUE;
 369                 goto out;
 370         }
 371
 372         hit->msgid = _dbus_iter_get_string_or_null (&child);
 373
 374         res = dbus_message_iter_next (&child);
 375         if (res == FALSE) {
 376                 error = TRUE;
 377                 goto out;
 378         }
 379
 380         /* subject  */
 381         arg_type = dbus_message_iter_get_arg_type (&child);
 382
 383         if (arg_type != DBUS_TYPE_STRING) {
 384                 error = TRUE;
 385                 goto out;
 386         }
 387
 388         hit->subject = _dbus_iter_get_string_or_null (&child);
 389
 390         res = dbus_message_iter_next (&child);
 391         if (res == FALSE) {
 392                 error = TRUE;
 393                 goto out;
 394         }
 395
 396         /* folder  */
 397         arg_type = dbus_message_iter_get_arg_type (&child);
 398
 399         if (arg_type != DBUS_TYPE_STRING) {
 400                 error = TRUE;
 401                 goto out;
 402         }
 403
 404         hit->folder = _dbus_iter_get_string_or_null (&child);
 405
 406         res = dbus_message_iter_next (&child);
 407         if (res == FALSE) {
 408                 error = TRUE;
 409                 goto out;
 410         }
 411
 412         /* sender  */
 413         arg_type = dbus_message_iter_get_arg_type (&child);
 414
 415         if (arg_type != DBUS_TYPE_STRING) {
 416                 error = TRUE;
 417                 goto out;
 418         }
 419
 420         hit->sender = _dbus_iter_get_string_or_null (&child);
 421
 422         res = dbus_message_iter_next (&child);
 423         if (res == FALSE) {
 424                 error = TRUE;
 425                 goto out;
 426         }
 427
 428         /* msize  */
 429         arg_type = dbus_message_iter_get_arg_type (&child);
 430
 431         if (arg_type != DBUS_TYPE_UINT64) {
 432                 error = TRUE;
 433                 goto out;
 434         }
 435
 436         hit->msize = _dbus_iter_get_uint64 (&child);
 437
 438         res = dbus_message_iter_next (&child);
 439         if (res == FALSE) {
 440                 error = TRUE;
 441                 goto out;
 442         }
 443
 444         /* has_attachment  */
 445         arg_type = dbus_message_iter_get_arg_type (&child);
 446
 447         if (arg_type != DBUS_TYPE_BOOLEAN) {
 448                 error = TRUE;
 449                 goto out;
 450         }
 451
 452         hit->has_attachment = _dbus_iter_get_boolean (&child);
 453
 454         res = dbus_message_iter_next (&child);
 455         if (res == FALSE) {
 456                 error = TRUE;
 457                 goto out;
 458         }
 459
 460         /* is_unread  */
 461         arg_type = dbus_message_iter_get_arg_type (&child);
 462
 463         if (arg_type != DBUS_TYPE_BOOLEAN) {
 464                 error = TRUE;
 465                 goto out;
 466         }
 467
 468         hit->is_unread = _dbus_iter_get_boolean (&child);
 469
 470         res = dbus_message_iter_next (&child);
 471         if (res == FALSE) {
 472                 error = TRUE;
 473                 goto out;
 474         }
 475
 476         /* msize  */
 477         arg_type = dbus_message_iter_get_arg_type (&child);
 478
 479         if (arg_type != DBUS_TYPE_INT64) {
 480                 error = TRUE;
 481                 goto out;
 482         }
 483
 484         hit->timestamp = _dbus_iter_get_int64 (&child);
 485
 486         res = dbus_message_iter_next (&child);
 487         if (res == TRUE) {
 488                 error = TRUE;
 489                 goto out;
 490         }
 491
 492 out:
 493         if (error) {
 494                 g_warning ("Error during unmarshaling");
 495                 modest_search_hit_free (hit);
 496                 hit = NULL;
 497         }
 498
 499         return hit;
 500 }
 501
 502 /**
 503  * libmodest_dbus_client_search:
 504  * @osso_ctx: A valid #osso_context_t object.
 505  * @query: The term to search for.
 506  * @folder: An url to specific folder or %NULL to search everywhere.
 507  * @start_date: Search hits before this date will be ignored.
 508  * @end_date: Search hits after this date will be ignored.
 509  * @min_size: Messagers smaller then this size will be ingored.
 510  * @flags: A list of flags where to search so the documentation
 511  * of %ModestDBusSearchFlags for details.
 512  * @hits: A pointer to a valid GList pointer that will contain the search
 513  * hits (must be freed by the caller).
 514  *
 515  * This method will search the folder specified by a valid url in @folder or all
 516  * known accounts (local and remote) if %NULL for matches of the search term(s)
 517  * specified in @query. It is legal to specify 0 in @start_date, @end_date and
 518  * @min_size to ignore these parameters during the search otherwise those message
 519  * that do not meet the specifed dates or size will be ignored.
 520  * Where to search, be it subject, sender or the whole body can be specified by
 521  * the @flags parameter.
 522  *
 523  * Upon success TRUE is returned and @hits will include the search hits or the list
 524  * migh be empty if none of the messages matched the search criteria. The returned
 525  * list must be freed with modest_search_hit_list_free (). It is save to pass
 526  * %NULL to this function so you can call this function on the result list no matter
 527  * if a hit was found or not (means the list is empty - i.e. %NULL)
 528  * FALSE will only be return if an error during the remote procedure call (rpc)
 529  * occured or if the specified folder could not be found.
 530  *
 531  * NOTE: The body of a message can only be searched if it was previously downloaded by
 532  * modest. This function does also not attempt do to remote searches (i.e. IMAP search).
 533  *
 534  * Example to search every account for message containing "no":
 535  * <informalexample><programlisting>
 536  * ModestDBusSearchFlags  flags;
 537  * osso_context_t        *osso_context;
 538  * GList                 *hits;
 539  * GList                 *iter;
 540  * gboolean               res;
 541  *
 542  * [...] Initialize osso context [...]
 543  *
 544  * res = libmodest_dbus_client_search (osso_context,
 545  *                                     "no",
 546  *                                     NULL,
 547  *                                     0,
 548  *                                     0,
 549  *                                     0,
 550  *                                     flags,
 551  *                                     &hits);
 552  *
 553  * for (iter = hits; iter; iter = iter->next) {
 554  *      ModestSearchHit *hit = (ModestSearchHit *) iter->data;
 555  *
 556  *      [...] Do something with the hit [...]
 557  *
 558  *      }
 559  *
 560  *      modest_search_hit_list_free (hits);
 561  * </programlisting></informalexample>
 562  *
 563  * Return value: TRUE if the search succeded or FALSE for an error during the search
 564  **/
 565 gboolean
 566 libmodest_dbus_client_search (osso_context_t          *osso_ctx,
 567                               const gchar             *query,
 568                               const gchar             *folder,
 569                               time_t                   start_date,
 570                               time_t                   end_date,
 571                               guint32                  min_size,
 572                               ModestDBusSearchFlags    flags,
 573                               GList                  **hits)
 574 {
 575
 576         DBusMessage *msg;
 577         dbus_bool_t res;
 578         DBusError err;
 579         DBusConnection *con;
 580         DBusMessageIter iter;
 581         DBusMessageIter child;
 582         DBusMessage *reply = NULL;
 583         gint timeout;
 584         int          arg_type;
 585         dbus_int64_t sd_v;
 586         dbus_int64_t ed_v;
 587         dbus_int32_t flags_v;
 588         dbus_uint32_t size_v;
 589
 590         if (query == NULL) {
 591                 return FALSE;
 592         }
 593
 594         con = osso_get_dbus_connection (osso_ctx);
 595
 596         if (con == NULL) {
 597                 g_warning ("Could not get dbus connection\n");
 598                 return FALSE;
 599
 600         }
 601
 602
 603         msg = dbus_message_new_method_call (MODEST_DBUS_SERVICE,
 604                                             MODEST_DBUS_OBJECT,
 605                                             MODEST_DBUS_IFACE,
 606                                             MODEST_DBUS_METHOD_SEARCH);
 607
 608         if (msg == NULL) {
 609                 //ULOG_ERR_F("dbus_message_new_method_call failed");
 610                 return OSSO_ERROR;
 611         }
 612
 613         if (folder == NULL) {
 614                 folder = "";
 615         }
 616
 617         sd_v = start_date;
 618         ed_v = end_date;
 619         flags_v = (dbus_int32_t) flags;
 620         size_v = (dbus_uint32_t) min_size;
 621
 622         res  = dbus_message_append_args (msg,
 623                                          DBUS_TYPE_STRING, &query,
 624                                          DBUS_TYPE_STRING, &folder,
 625                                          DBUS_TYPE_INT64, &sd_v,
 626                                          DBUS_TYPE_INT64, &ed_v,
 627                                          DBUS_TYPE_INT32, &flags_v,
 628                                          DBUS_TYPE_UINT32, &size_v,
 629                                          DBUS_TYPE_INVALID);
 630
 631         dbus_message_set_auto_start (msg, TRUE);
 632
 633         dbus_error_init (&err);
 634
 635         timeout = 1000; //XXX
 636         osso_rpc_get_timeout (osso_ctx, &timeout);
 637
 638         reply = dbus_connection_send_with_reply_and_block (con,
 639                                                            msg,
 640                                                            timeout,
 641                                                            &err);
 642
 643         dbus_message_unref (msg);
 644
 645
 646         if (reply == NULL) {
 647             //ULOG_ERR_F("dbus_connection_send_with_reply_and_block error: %s", err.message);
 648             //XXX to GError?!
 649             return FALSE;
 650         }
 651
 652         switch (dbus_message_get_type (reply)) {
 653
 654                 case DBUS_MESSAGE_TYPE_ERROR:
 655                         dbus_set_error_from_message (&err, reply);
 656                         //XXX to GError?!
 657                         dbus_error_free (&err);
 658                         dbus_message_unref (reply);
 659                         return FALSE;
 660
 661                 case DBUS_MESSAGE_TYPE_METHOD_RETURN:
 662                         /* ok we are good to go
 663                          * lets drop outa here and handle that */
 664                         break;
 665                 default:
 666                         //ULOG_WARN_F("got unknown message type as reply");
 667                         //retval->type = DBUS_TYPE_STRING;
 668                         //retval->value.s = g_strdup("Invalid return value");
 669                         //XXX to GError?!
 670                         dbus_message_unref (reply);
 671                         return FALSE;
 672         }
 673
 674         g_debug ("message return");
 675
 676         dbus_message_iter_init (reply, &iter);
 677         arg_type = dbus_message_iter_get_arg_type (&iter);
 678
 679         dbus_message_iter_recurse (&iter, &child);
 680         *hits = NULL;
 681
 682         do {
 683                 ModestSearchHit *hit;
 684
 685                 hit = dbus_message_iter_get_search_hit (&child);
 686
 687                 if (hit) {
 688                         *hits = g_list_prepend (*hits, hit);
 689                 }
 690
 691         } while (dbus_message_iter_next (&child));
 692
 693         dbus_message_unref (reply);
 694
 695
 696         /* TODO: This is from osso source, do we need it? */
 697 #if 0
 698         /* Tell TaskNavigator to show "launch banner" */
 699         msg = dbus_message_new_method_call (TASK_NAV_SERVICE,
 700                                             APP_LAUNCH_BANNER_METHOD_PATH,
 701                                             APP_LAUNCH_BANNER_METHOD_INTERFACE,
 702                                             APP_LAUNCH_BANNER_METHOD);
 703
 704         if (msg == NULL) {
 705                 g_warn ("dbus_message_new_method_call failed");
 706         }
 707
 708
 709
 710         dbus_message_append_args (msg,
 711                                   DBUS_TYPE_STRING,
 712                                   &service,
 713                                   DBUS_TYPE_INVALID);
 714
 715         b = dbus_connection_send (conn, msg, NULL);
 716
 717         if (b == NULL) {
 718                 ULOG_WARN_F("dbus_connection_send failed");
 719         }
 720
 721         dbus_message_unref (msg);
 722 #endif
 723
 724         return TRUE;
 725 }
 726