libempathy/empathy-idle.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007-2008 Collabora Ltd.
   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.1 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 Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Xavier Claessens <xclaesse@gmail.com>
  20  */
  21
  22 #include <config.h>
  23
  24 #include <string.h>
  25
  26 #include <glib/gi18n.h>
  27 #include <dbus/dbus-glib.h>
  28
  29 #include <telepathy-glib/dbus.h>
  30 #include <telepathy-glib/util.h>
  31 #include <libmissioncontrol/mc-enum-types.h>
  32
  33 #include "empathy-idle.h"
  34 #include "empathy-utils.h"
  35
  36 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  37 #include "empathy-debug.h"
  38
  39 /* Number of seconds before entering extended autoaway. */
  40 #define EXT_AWAY_TIME (30*60)
  41
  42 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIdle)
  43 typedef struct {
  44         MissionControl *mc;
  45         DBusGProxy     *gs_proxy;
  46         DBusGProxy     *nm_proxy;
  47
  48         McPresence      state;
  49         gchar          *status;
  50         McPresence      flash_state;
  51         gboolean        auto_away;
  52         gboolean        use_nm;
  53
  54         McPresence      away_saved_state;
  55         McPresence      nm_saved_state;
  56
  57         gboolean        is_idle;
  58         gboolean        nm_connected;
  59         guint           ext_away_timeout;
  60 } EmpathyIdlePriv;
  61
  62 typedef enum {
  63         NM_STATE_UNKNOWN,
  64         NM_STATE_ASLEEP,
  65         NM_STATE_CONNECTING,
  66         NM_STATE_CONNECTED,
  67         NM_STATE_DISCONNECTED
  68 } NMState;
  69
  70 enum {
  71         PROP_0,
  72         PROP_STATE,
  73         PROP_STATUS,
  74         PROP_FLASH_STATE,
  75         PROP_AUTO_AWAY,
  76         PROP_USE_NM
  77 };
  78
  79 G_DEFINE_TYPE (EmpathyIdle, empathy_idle, G_TYPE_OBJECT)
  80
  81 static void
  82 idle_presence_changed_cb (MissionControl *mc,
  83                           McPresence      state,
  84                           gchar          *status,
  85                           EmpathyIdle    *idle)
  86 {
  87         EmpathyIdlePriv *priv;
  88
  89         priv = GET_PRIV (idle);
  90
  91         DEBUG ("Presence changed to '%s' (%d)", status, state);
  92
  93         g_free (priv->status);
  94         priv->state = state;
  95         priv->status = NULL;
  96         if (!G_STR_EMPTY (status)) {
  97                 priv->status = g_strdup (status);
  98         }
  99
 100         g_object_notify (G_OBJECT (idle), "state");
 101         g_object_notify (G_OBJECT (idle), "status");
 102 }
 103
 104 static gboolean
 105 idle_ext_away_cb (EmpathyIdle *idle)
 106 {
 107         EmpathyIdlePriv *priv;
 108
 109         priv = GET_PRIV (idle);
 110
 111         DEBUG ("Going to extended autoaway");
 112         empathy_idle_set_state (idle, MC_PRESENCE_EXTENDED_AWAY);
 113         priv->ext_away_timeout = 0;
 114
 115         return FALSE;
 116 }
 117
 118 static void
 119 idle_ext_away_stop (EmpathyIdle *idle)
 120 {
 121         EmpathyIdlePriv *priv;
 122
 123         priv = GET_PRIV (idle);
 124
 125         if (priv->ext_away_timeout) {
 126                 g_source_remove (priv->ext_away_timeout);
 127                 priv->ext_away_timeout = 0;
 128         }
 129 }
 130
 131 static void
 132 idle_ext_away_start (EmpathyIdle *idle)
 133 {
 134         EmpathyIdlePriv *priv;
 135
 136         priv = GET_PRIV (idle);
 137
 138         if (priv->ext_away_timeout != 0) {
 139                 return;
 140         }
 141         priv->ext_away_timeout = g_timeout_add_seconds (EXT_AWAY_TIME,
 142                                                         (GSourceFunc) idle_ext_away_cb,
 143                                                         idle);
 144 }
 145
 146 static void
 147 idle_session_idle_changed_cb (DBusGProxy  *gs_proxy,
 148                               gboolean     is_idle,
 149                               EmpathyIdle *idle)
 150 {
 151         EmpathyIdlePriv *priv;
 152
 153         priv = GET_PRIV (idle);
 154
 155         DEBUG ("Session idle state changed, %s -> %s",
 156                 priv->is_idle ? "yes" : "no",
 157                 is_idle ? "yes" : "no");
 158
 159         if (!priv->auto_away ||
 160             (priv->nm_saved_state == MC_PRESENCE_UNSET &&
 161              (priv->state <= MC_PRESENCE_OFFLINE ||
 162               priv->state == MC_PRESENCE_HIDDEN))) {
 163                 /* We don't want to go auto away OR we explicitely asked to be
 164                  * offline, nothing to do here */
 165                 priv->is_idle = is_idle;
 166                 return;
 167         }
 168
 169         if (is_idle && !priv->is_idle) {
 170                 McPresence new_state;
 171                 /* We are now idle */
 172
 173                 idle_ext_away_start (idle);
 174
 175                 if (priv->nm_saved_state != MC_PRESENCE_UNSET) {
 176                         /* We are disconnected, when coming back from away
 177                          * we want to restore the presence before the
 178                          * disconnection. */
 179                         priv->away_saved_state = priv->nm_saved_state;
 180                 } else {
 181                         priv->away_saved_state = priv->state;
 182                 }
 183
 184                 new_state = MC_PRESENCE_AWAY;
 185                 if (priv->state == MC_PRESENCE_EXTENDED_AWAY) {
 186                         new_state = MC_PRESENCE_EXTENDED_AWAY;
 187                 }
 188
 189                 DEBUG ("Going to autoaway. Saved state=%d, new state=%d",
 190                         priv->away_saved_state, new_state);
 191                 empathy_idle_set_state (idle, new_state);
 192         } else if (!is_idle && priv->is_idle) {
 193                 const gchar *new_status;
 194                 /* We are no more idle, restore state */
 195
 196                 idle_ext_away_stop (idle);
 197
 198                 if (priv->away_saved_state == MC_PRESENCE_AWAY ||
 199                     priv->away_saved_state == MC_PRESENCE_EXTENDED_AWAY) {
 200                         priv->away_saved_state = MC_PRESENCE_AVAILABLE;
 201                         new_status = NULL;
 202                 } else {
 203                         new_status = priv->status;
 204                 }
 205
 206                 DEBUG ("Restoring state to %d, reset status to %s",
 207                         priv->away_saved_state, new_status);
 208
 209                 empathy_idle_set_presence (idle,
 210                                            priv->away_saved_state,
 211                                            new_status);
 212
 213                 priv->away_saved_state = MC_PRESENCE_UNSET;
 214         }
 215
 216         priv->is_idle = is_idle;
 217 }
 218
 219 static void
 220 idle_nm_state_change_cb (DBusGProxy  *proxy,
 221                          guint        state,
 222                          EmpathyIdle *idle)
 223 {
 224         EmpathyIdlePriv *priv;
 225         gboolean         old_nm_connected;
 226         gboolean         new_nm_connected;
 227
 228         priv = GET_PRIV (idle);
 229
 230         if (!priv->use_nm) {
 231                 return;
 232         }
 233
 234         old_nm_connected = priv->nm_connected;
 235         new_nm_connected = !(state == NM_STATE_CONNECTING ||
 236                              state == NM_STATE_DISCONNECTED);
 237         priv->nm_connected = TRUE; /* To be sure _set_state will work */
 238
 239         DEBUG ("New network state %d", state);
 240
 241         if (old_nm_connected && !new_nm_connected) {
 242                 /* We are no more connected */
 243                 DEBUG ("Disconnected: Save state %d", priv->state);
 244                 priv->nm_saved_state = priv->state;
 245                 empathy_idle_set_state (idle, MC_PRESENCE_OFFLINE);
 246         }
 247         else if (!old_nm_connected && new_nm_connected) {
 248                 /* We are now connected */
 249                 DEBUG ("Reconnected: Restore state %d", priv->nm_saved_state);
 250                 empathy_idle_set_state (idle, priv->nm_saved_state);
 251                 priv->nm_saved_state = MC_PRESENCE_UNSET;
 252         }
 253
 254         priv->nm_connected = new_nm_connected;
 255 }
 256
 257 static void
 258 idle_finalize (GObject *object)
 259 {
 260         EmpathyIdlePriv *priv;
 261
 262         priv = GET_PRIV (object);
 263
 264         g_free (priv->status);
 265         g_object_unref (priv->mc);
 266
 267         if (priv->gs_proxy) {
 268                 g_object_unref (priv->gs_proxy);
 269         }
 270
 271         idle_ext_away_stop (EMPATHY_IDLE (object));
 272 }
 273
 274 static void
 275 idle_get_property (GObject    *object,
 276                    guint       param_id,
 277                    GValue     *value,
 278                    GParamSpec *pspec)
 279 {
 280         EmpathyIdlePriv *priv;
 281         EmpathyIdle     *idle;
 282
 283         priv = GET_PRIV (object);
 284         idle = EMPATHY_IDLE (object);
 285
 286         switch (param_id) {
 287         case PROP_STATE:
 288                 g_value_set_enum (value, empathy_idle_get_state (idle));
 289                 break;
 290         case PROP_STATUS:
 291                 g_value_set_string (value, empathy_idle_get_status (idle));
 292                 break;
 293         case PROP_FLASH_STATE:
 294                 g_value_set_enum (value, empathy_idle_get_flash_state (idle));
 295                 break;
 296         case PROP_AUTO_AWAY:
 297                 g_value_set_boolean (value, empathy_idle_get_auto_away (idle));
 298                 break;
 299         case PROP_USE_NM:
 300                 g_value_set_boolean (value, empathy_idle_get_use_nm (idle));
 301                 break;
 302         default:
 303                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 304                 break;
 305         };
 306 }
 307
 308 static void
 309 idle_set_property (GObject      *object,
 310                    guint         param_id,
 311                    const GValue *value,
 312                    GParamSpec   *pspec)
 313 {
 314         EmpathyIdlePriv *priv;
 315         EmpathyIdle     *idle;
 316
 317         priv = GET_PRIV (object);
 318         idle = EMPATHY_IDLE (object);
 319
 320         switch (param_id) {
 321         case PROP_STATE:
 322                 empathy_idle_set_state (idle, g_value_get_enum (value));
 323                 break;
 324         case PROP_STATUS:
 325                 empathy_idle_set_status (idle, g_value_get_string (value));
 326                 break;
 327         case PROP_FLASH_STATE:
 328                 empathy_idle_set_flash_state (idle, g_value_get_enum (value));
 329                 break;
 330         case PROP_AUTO_AWAY:
 331                 empathy_idle_set_auto_away (idle, g_value_get_boolean (value));
 332                 break;
 333         case PROP_USE_NM:
 334                 empathy_idle_set_use_nm (idle, g_value_get_boolean (value));
 335                 break;
 336         default:
 337                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 338                 break;
 339         };
 340 }
 341
 342 static void
 343 empathy_idle_class_init (EmpathyIdleClass *klass)
 344 {
 345         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 346
 347         object_class->finalize = idle_finalize;
 348         object_class->get_property = idle_get_property;
 349         object_class->set_property = idle_set_property;
 350
 351         g_object_class_install_property (object_class,
 352                                          PROP_STATE,
 353                                          g_param_spec_enum ("state",
 354                                                             "state",
 355                                                             "state",
 356                                                             MC_TYPE_PRESENCE,
 357                                                             MC_PRESENCE_AVAILABLE,
 358                                                             G_PARAM_READWRITE));
 359         g_object_class_install_property (object_class,
 360                                          PROP_STATUS,
 361                                          g_param_spec_string ("status",
 362                                                               "status",
 363                                                               "status",
 364                                                               NULL,
 365                                                               G_PARAM_READWRITE));
 366         g_object_class_install_property (object_class,
 367                                          PROP_FLASH_STATE,
 368                                          g_param_spec_enum ("flash-state",
 369                                                             "flash-state",
 370                                                             "flash-state",
 371                                                             MC_TYPE_PRESENCE,
 372                                                             MC_PRESENCE_UNSET,
 373                                                             G_PARAM_READWRITE));
 374
 375          g_object_class_install_property (object_class,
 376                                           PROP_AUTO_AWAY,
 377                                           g_param_spec_boolean ("auto-away",
 378                                                                 "Automatic set presence to away",
 379                                                                 "Should it set presence to away if inactive",
 380                                                                 FALSE,
 381                                                                 G_PARAM_READWRITE));
 382
 383          g_object_class_install_property (object_class,
 384                                           PROP_USE_NM,
 385                                           g_param_spec_boolean ("use-nm",
 386                                                                 "Use Network Manager",
 387                                                                 "Set presence according to Network Manager",
 388                                                                 FALSE,
 389                                                                 G_PARAM_READWRITE));
 390
 391         g_type_class_add_private (object_class, sizeof (EmpathyIdlePriv));
 392 }
 393
 394 static void
 395 empathy_idle_init (EmpathyIdle *idle)
 396 {
 397         DBusGConnection *system_bus;
 398         GError          *error = NULL;
 399         EmpathyIdlePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (idle,
 400                 EMPATHY_TYPE_IDLE, EmpathyIdlePriv);
 401
 402         idle->priv = priv;
 403         priv->is_idle = FALSE;
 404         priv->mc = empathy_mission_control_new ();
 405         priv->state = mission_control_get_presence_actual (priv->mc, NULL);
 406         priv->status = mission_control_get_presence_message_actual (priv->mc, NULL);
 407         if (G_STR_EMPTY (priv->status)) {
 408                 g_free (priv->status);
 409                 priv->status = NULL;
 410         }
 411
 412         dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc),
 413                                      "PresenceChanged",
 414                                      G_CALLBACK (idle_presence_changed_cb),
 415                                      idle, NULL);
 416
 417         priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (),
 418                                                     "org.gnome.ScreenSaver",
 419                                                     "/org/gnome/ScreenSaver",
 420                                                     "org.gnome.ScreenSaver");
 421         if (priv->gs_proxy) {
 422                 dbus_g_proxy_add_signal (priv->gs_proxy, "SessionIdleChanged",
 423                                          G_TYPE_BOOLEAN,
 424                                          G_TYPE_INVALID);
 425                 dbus_g_proxy_connect_signal (priv->gs_proxy, "SessionIdleChanged",
 426                                              G_CALLBACK (idle_session_idle_changed_cb),
 427                                              idle, NULL);
 428         } else {
 429                 DEBUG ("Failed to get gs proxy");
 430         }
 431
 432
 433         system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
 434         if (!system_bus) {
 435                 DEBUG ("Failed to get system bus: %s",
 436                         error ? error->message : "No error given");
 437         } else {
 438                 priv->nm_proxy = dbus_g_proxy_new_for_name (system_bus,
 439                                                             "org.freedesktop.NetworkManager",
 440                                                             "/org/freedesktop/NetworkManager",
 441                                                             "org.freedesktop.NetworkManager");
 442         }
 443         if (priv->nm_proxy) {
 444                 dbus_g_proxy_add_signal (priv->nm_proxy, "StateChange",
 445                                          G_TYPE_UINT, G_TYPE_INVALID);
 446                 dbus_g_proxy_connect_signal (priv->nm_proxy, "StateChange",
 447                                              G_CALLBACK (idle_nm_state_change_cb),
 448                                              idle, NULL);
 449         } else {
 450                 DEBUG ("Failed to get nm proxy");
 451         }
 452
 453         priv->nm_connected = TRUE;
 454 }
 455
 456 EmpathyIdle *
 457 empathy_idle_new (void)
 458 {
 459         static EmpathyIdle *idle = NULL;
 460
 461         if (!idle) {
 462                 idle = g_object_new (EMPATHY_TYPE_IDLE, NULL);
 463                 g_object_add_weak_pointer (G_OBJECT (idle), (gpointer) &idle);
 464         } else {
 465                 g_object_ref (idle);
 466         }
 467
 468         return idle;
 469 }
 470
 471 McPresence
 472 empathy_idle_get_state (EmpathyIdle *idle)
 473 {
 474         EmpathyIdlePriv *priv;
 475
 476         priv = GET_PRIV (idle);
 477
 478         return priv->state;
 479 }
 480
 481 void
 482 empathy_idle_set_state (EmpathyIdle *idle,
 483                         McPresence   state)
 484 {
 485         EmpathyIdlePriv *priv;
 486
 487         priv = GET_PRIV (idle);
 488
 489         empathy_idle_set_presence (idle, state, priv->status);
 490 }
 491
 492 const gchar *
 493 empathy_idle_get_status (EmpathyIdle *idle)
 494 {
 495         EmpathyIdlePriv *priv;
 496
 497         priv = GET_PRIV (idle);
 498
 499         if (!priv->status) {
 500                 return empathy_presence_get_default_message (priv->state);
 501         }
 502
 503         return priv->status;
 504 }
 505
 506 void
 507 empathy_idle_set_status (EmpathyIdle *idle,
 508                          const gchar *status)
 509 {
 510         EmpathyIdlePriv *priv;
 511
 512         priv = GET_PRIV (idle);
 513
 514         empathy_idle_set_presence (idle, priv->state, status);
 515 }
 516
 517 McPresence
 518 empathy_idle_get_flash_state (EmpathyIdle *idle)
 519 {
 520         EmpathyIdlePriv *priv;
 521
 522         priv = GET_PRIV (idle);
 523
 524         return priv->flash_state;
 525 }
 526
 527 void
 528 empathy_idle_set_flash_state (EmpathyIdle *idle,
 529                               McPresence   state)
 530 {
 531         EmpathyIdlePriv *priv;
 532
 533         priv = GET_PRIV (idle);
 534
 535         priv->flash_state = state;
 536
 537         if (state == MC_PRESENCE_UNSET) {
 538         }
 539
 540         g_object_notify (G_OBJECT (idle), "flash-state");
 541 }
 542
 543 void
 544 empathy_idle_set_presence (EmpathyIdle *idle,
 545                            McPresence   state,
 546                            const gchar *status)
 547 {
 548         EmpathyIdlePriv *priv;
 549         const gchar     *default_status;
 550
 551         priv = GET_PRIV (idle);
 552
 553         DEBUG ("Changing presence to %s (%d)", status, state);
 554
 555         /* Do not set translated default messages */
 556         default_status = empathy_presence_get_default_message (state);
 557         if (!tp_strdiff (status, default_status)) {
 558                 status = NULL;
 559         }
 560
 561         if (!priv->nm_connected) {
 562                 DEBUG ("NM not connected");
 563
 564                 priv->nm_saved_state = state;
 565                 if (tp_strdiff (priv->status, status)) {
 566                         g_free (priv->status);
 567                         priv->status = NULL;
 568                         if (!G_STR_EMPTY (status)) {
 569                                 priv->status = g_strdup (status);
 570                         }
 571                         g_object_notify (G_OBJECT (idle), "status");
 572                 }
 573
 574                 return;
 575         }
 576
 577         mission_control_set_presence (priv->mc, state, status, NULL, NULL);
 578 }
 579
 580 gboolean
 581 empathy_idle_get_auto_away (EmpathyIdle *idle)
 582 {
 583         EmpathyIdlePriv *priv = GET_PRIV (idle);
 584
 585         return priv->auto_away;
 586 }
 587
 588 void
 589 empathy_idle_set_auto_away (EmpathyIdle *idle,
 590                             gboolean     auto_away)
 591 {
 592         EmpathyIdlePriv *priv = GET_PRIV (idle);
 593
 594         priv->auto_away = auto_away;
 595
 596         g_object_notify (G_OBJECT (idle), "auto-away");
 597 }
 598
 599 gboolean
 600 empathy_idle_get_use_nm (EmpathyIdle *idle)
 601 {
 602         EmpathyIdlePriv *priv = GET_PRIV (idle);
 603
 604         return priv->use_nm;
 605 }
 606
 607 void
 608 empathy_idle_set_use_nm (EmpathyIdle *idle,
 609                          gboolean     use_nm)
 610 {
 611         EmpathyIdlePriv *priv = GET_PRIV (idle);
 612
 613         if (!priv->nm_proxy || use_nm == priv->use_nm) {
 614                 return;
 615         }
 616
 617         priv->use_nm = use_nm;
 618
 619         if (use_nm) {
 620                 guint   nm_status;
 621                 GError *error = NULL;
 622
 623                 dbus_g_proxy_call (priv->nm_proxy, "state",
 624                                    &error,
 625                                    G_TYPE_INVALID,
 626                                    G_TYPE_UINT, &nm_status,
 627                                    G_TYPE_INVALID);
 628
 629                 if (error) {
 630                         DEBUG ("Couldn't get NM state: %s", error->message);
 631                         g_clear_error (&error);
 632                         nm_status = NM_STATE_ASLEEP;
 633                 }
 634
 635                 idle_nm_state_change_cb (priv->nm_proxy, nm_status, idle);
 636         } else {
 637                 priv->nm_connected = TRUE;
 638                 if (priv->nm_saved_state != MC_PRESENCE_UNSET) {
 639                         empathy_idle_set_state (idle, priv->nm_saved_state);
 640                 }
 641                 priv->nm_saved_state = MC_PRESENCE_UNSET;
 642         }
 643
 644         g_object_notify (G_OBJECT (idle), "use-nm");
 645 }
 646