libempathy/empathy-idle.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Collabora Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program 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  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Authors: Xavier Claessens <xclaesse@gmail.com>
  21  */
  22
  23 #include <config.h>
  24
  25 #include <string.h>
  26
  27 #include <glib/gi18n.h>
  28 #include <dbus/dbus-glib.h>
  29
  30 #include <libtelepathy/tp-helpers.h>
  31
  32 #include "empathy-idle.h"
  33 #include "empathy-utils.h"
  34 #include "empathy-debug.h"
  35
  36 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
  37                        EMPATHY_TYPE_IDLE, EmpathyIdlePriv))
  38
  39 #define DEBUG_DOMAIN "Idle"
  40
  41 /* Number of seconds before entering extended autoaway. */
  42 #define EXT_AWAY_TIME (30*60)
  43
  44 typedef enum {
  45         NM_STATE_UNKNOWN = 0,
  46         NM_STATE_ASLEEP,
  47         NM_STATE_CONNECTING,
  48         NM_STATE_CONNECTED,
  49         NM_STATE_DISCONNECTED
  50 } NMState;
  51
  52 struct _EmpathyIdlePriv {
  53         MissionControl *mc;
  54         DBusGProxy     *gs_proxy;
  55         DBusGProxy     *nm_proxy;
  56         gboolean        is_idle;
  57         McPresence      state;
  58         McPresence      flash_state;
  59         gchar          *status;
  60         McPresence      saved_state;
  61         gchar          *saved_status;
  62         gboolean        nm_connected;
  63         guint           ext_away_timeout;
  64 };
  65
  66 static void     empathy_idle_class_init      (EmpathyIdleClass *klass);
  67 static void     empathy_idle_init            (EmpathyIdle      *idle);
  68 static void     idle_finalize                (GObject          *object);
  69 static void     idle_get_property            (GObject          *object,
  70                                               guint             param_id,
  71                                               GValue           *value,
  72                                               GParamSpec       *pspec);
  73 static void     idle_set_property            (GObject          *object,
  74                                               guint             param_id,
  75                                               const GValue     *value,
  76                                               GParamSpec       *pspec);
  77 static void     idle_presence_changed_cb     (MissionControl   *mc,
  78                                               McPresence        state,
  79                                               EmpathyIdle      *idle);
  80 static void     idle_session_idle_changed_cb (DBusGProxy       *gs_proxy,
  81                                               gboolean          is_idle,
  82                                               EmpathyIdle      *idle);
  83 static void     idle_nm_state_change_cb      (DBusGProxy       *proxy,
  84                                               guint             state,
  85                                               EmpathyIdle      *idle);
  86 static void     idle_ext_away_start          (EmpathyIdle      *idle);
  87 static void     idle_ext_away_stop           (EmpathyIdle      *idle);
  88 static gboolean idle_ext_away_cb             (EmpathyIdle      *idle);
  89
  90 enum {
  91         PROP_0,
  92         PROP_STATE,
  93         PROP_STATUS,
  94         PROP_FLASH_STATE
  95 };
  96
  97 G_DEFINE_TYPE (EmpathyIdle, empathy_idle, G_TYPE_OBJECT)
  98
  99 static void
 100 empathy_idle_class_init (EmpathyIdleClass *klass)
 101 {
 102         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 103
 104         object_class->finalize = idle_finalize;
 105         object_class->get_property = idle_get_property;
 106         object_class->set_property = idle_set_property;
 107
 108         g_object_class_install_property (object_class,
 109                                          PROP_STATE,
 110                                          g_param_spec_uint ("state",
 111                                                             "state",
 112                                                             "state",
 113                                                             MC_PRESENCE_UNSET,
 114                                                             LAST_MC_PRESENCE,
 115                                                             MC_PRESENCE_AVAILABLE,
 116                                                             G_PARAM_READWRITE));
 117         g_object_class_install_property (object_class,
 118                                          PROP_STATUS,
 119                                          g_param_spec_string ("status",
 120                                                               "status",
 121                                                               "status",
 122                                                               NULL,
 123                                                               G_PARAM_READWRITE));
 124         g_object_class_install_property (object_class,
 125                                          PROP_FLASH_STATE,
 126                                          g_param_spec_uint ("flash-state",
 127                                                             "flash-state",
 128                                                             "flash-state",
 129                                                             MC_PRESENCE_UNSET,
 130                                                             LAST_MC_PRESENCE,
 131                                                             MC_PRESENCE_UNSET,
 132                                                             G_PARAM_READWRITE));
 133
 134         g_type_class_add_private (object_class, sizeof (EmpathyIdlePriv));
 135 }
 136
 137 static void
 138 empathy_idle_init (EmpathyIdle *idle)
 139 {
 140         EmpathyIdlePriv *priv;
 141         DBusGConnection *system_bus;
 142         GError          *error = NULL;
 143
 144         priv = GET_PRIV (idle);
 145
 146         priv->is_idle = FALSE;
 147         priv->mc = empathy_mission_control_new ();
 148         priv->state = mission_control_get_presence_actual (priv->mc, NULL);
 149         idle_presence_changed_cb (priv->mc, priv->state, idle);
 150
 151         dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc),
 152                                      "PresenceStatusActual",
 153                                      G_CALLBACK (idle_presence_changed_cb),
 154                                      idle, NULL);
 155
 156         priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (),
 157                                                     "org.gnome.ScreenSaver",
 158                                                     "/org/gnome/ScreenSaver",
 159                                                     "org.gnome.ScreenSaver");
 160         if (priv->gs_proxy) {
 161                 dbus_g_proxy_add_signal (priv->gs_proxy, "SessionIdleChanged",
 162                                          G_TYPE_BOOLEAN,
 163                                          G_TYPE_INVALID);
 164                 dbus_g_proxy_connect_signal (priv->gs_proxy, "SessionIdleChanged",
 165                                              G_CALLBACK (idle_session_idle_changed_cb),
 166                                              idle, NULL);
 167         } else {
 168                 empathy_debug (DEBUG_DOMAIN, "Failed to get gs proxy");
 169         }
 170
 171
 172         system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
 173         if (!system_bus) {
 174                 empathy_debug (DEBUG_DOMAIN, "Failed to get system bus: %s",
 175                               error ? error->message : "No error given");
 176         } else {
 177                 priv->nm_proxy = dbus_g_proxy_new_for_name (system_bus,
 178                                                             "org.freedesktop.NetworkManager",
 179                                                             "/org/freedesktop/NetworkManager",
 180                                                             "org.freedesktop.NetworkManager");
 181         }
 182         if (priv->nm_proxy) {
 183                 dbus_g_proxy_add_signal (priv->nm_proxy, "StateChange",
 184                                          G_TYPE_UINT, G_TYPE_INVALID);
 185                 dbus_g_proxy_connect_signal (priv->nm_proxy, "StateChange",
 186                                              G_CALLBACK (idle_nm_state_change_cb),
 187                                              idle, NULL);
 188         } else {
 189                 empathy_debug (DEBUG_DOMAIN, "Failed to get nm proxy");
 190         }
 191         /* FIXME: get value */
 192         priv->nm_connected = TRUE;
 193 }
 194
 195 static void
 196 idle_finalize (GObject *object)
 197 {
 198         EmpathyIdlePriv *priv;
 199
 200         priv = GET_PRIV (object);
 201
 202         g_free (priv->status);
 203         g_free (priv->saved_status);
 204         g_object_unref (priv->mc);
 205
 206         if (priv->gs_proxy) {
 207                 g_object_unref (priv->gs_proxy);
 208         }
 209
 210         idle_ext_away_stop (EMPATHY_IDLE (object));
 211 }
 212
 213 static void
 214 idle_get_property (GObject    *object,
 215                    guint       param_id,
 216                    GValue     *value,
 217                    GParamSpec *pspec)
 218 {
 219         EmpathyIdlePriv *priv;
 220         EmpathyIdle     *idle;
 221
 222         priv = GET_PRIV (object);
 223         idle = EMPATHY_IDLE (object);
 224
 225         switch (param_id) {
 226         case PROP_STATE:
 227                 g_value_set_uint (value, empathy_idle_get_state (idle));
 228                 break;
 229         case PROP_STATUS:
 230                 g_value_set_string (value, empathy_idle_get_status (idle));
 231                 break;
 232         case PROP_FLASH_STATE:
 233                 g_value_set_uint (value, empathy_idle_get_flash_state (idle));
 234                 break;
 235         default:
 236                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 237                 break;
 238         };
 239 }
 240
 241 static void
 242 idle_set_property (GObject      *object,
 243                    guint         param_id,
 244                    const GValue *value,
 245                    GParamSpec   *pspec)
 246 {
 247         EmpathyIdlePriv *priv;
 248         EmpathyIdle     *idle;
 249
 250         priv = GET_PRIV (object);
 251         idle = EMPATHY_IDLE (object);
 252
 253         switch (param_id) {
 254         case PROP_STATE:
 255                 empathy_idle_set_state (idle, g_value_get_uint (value));
 256                 break;
 257         case PROP_STATUS:
 258                 empathy_idle_set_status (idle, g_value_get_string (value));
 259                 break;
 260         case PROP_FLASH_STATE:
 261                 empathy_idle_set_flash_state (idle, g_value_get_uint (value));
 262                 break;
 263         default:
 264                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 265                 break;
 266         };
 267 }
 268
 269 EmpathyIdle *
 270 empathy_idle_new (void)
 271 {
 272         static EmpathyIdle *idle = NULL;
 273
 274         if (!idle) {
 275                 idle = g_object_new (EMPATHY_TYPE_IDLE, NULL);
 276                 g_object_add_weak_pointer (G_OBJECT (idle), (gpointer) &idle);
 277         } else {
 278                 g_object_ref (idle);
 279         }
 280
 281         return idle;
 282 }
 283
 284 McPresence
 285 empathy_idle_get_state (EmpathyIdle *idle)
 286 {
 287         EmpathyIdlePriv *priv;
 288
 289         priv = GET_PRIV (idle);
 290
 291         return priv->state;
 292 }
 293
 294 void
 295 empathy_idle_set_state (EmpathyIdle *idle,
 296                         McPresence   state)
 297 {
 298         EmpathyIdlePriv *priv;
 299
 300         priv = GET_PRIV (idle);
 301
 302         empathy_idle_set_presence (idle, state, priv->status);
 303 }
 304
 305 const gchar *
 306 empathy_idle_get_status (EmpathyIdle *idle)
 307 {
 308         EmpathyIdlePriv *priv;
 309
 310         priv = GET_PRIV (idle);
 311
 312         if (!priv->status) {
 313                 return empathy_presence_state_get_default_status (priv->state);
 314         }
 315
 316         return priv->status;
 317 }
 318
 319 void
 320 empathy_idle_set_status (EmpathyIdle *idle,
 321                          const gchar *status)
 322 {
 323         EmpathyIdlePriv *priv;
 324
 325         priv = GET_PRIV (idle);
 326
 327         empathy_idle_set_presence (idle, priv->state, status);
 328 }
 329
 330 McPresence
 331 empathy_idle_get_flash_state (EmpathyIdle *idle)
 332 {
 333         EmpathyIdlePriv *priv;
 334
 335         priv = GET_PRIV (idle);
 336
 337         return priv->flash_state;
 338 }
 339
 340 void
 341 empathy_idle_set_flash_state (EmpathyIdle *idle,
 342                               McPresence   state)
 343 {
 344         EmpathyIdlePriv *priv;
 345
 346         priv = GET_PRIV (idle);
 347
 348         priv->flash_state = state;
 349
 350         if (state == MC_PRESENCE_UNSET) {
 351         }
 352
 353         g_object_notify (G_OBJECT (idle), "flash-state");
 354 }
 355
 356 void
 357 empathy_idle_set_presence (EmpathyIdle *idle,
 358                            McPresence   state,
 359                            const gchar *status)
 360 {
 361         EmpathyIdlePriv *priv;
 362         const gchar     *default_status;
 363
 364         priv = GET_PRIV (idle);
 365
 366         if (!priv->nm_connected) {
 367                 g_free (priv->saved_status);
 368                 priv->saved_state = state;
 369                 priv->saved_status = g_strdup (status);
 370                 return;
 371         }
 372
 373         /* Do not set translated default messages */
 374         default_status = empathy_presence_state_get_default_status (state);
 375         if (status && strcmp (status, default_status) == 0) {
 376                 status = NULL;
 377         }
 378
 379         mission_control_set_presence (priv->mc,
 380                                       state,
 381                                       status,
 382                                       NULL, NULL);
 383 }
 384
 385 static void
 386 idle_presence_changed_cb (MissionControl *mc,
 387                           McPresence      state,
 388                           EmpathyIdle    *idle)
 389 {
 390         EmpathyIdlePriv *priv;
 391
 392         priv = GET_PRIV (idle);
 393
 394         g_free (priv->status);
 395         priv->state = state;
 396         priv->status = mission_control_get_presence_message_actual (priv->mc, NULL);
 397
 398         if (G_STR_EMPTY (priv->status)) {
 399                 g_free (priv->status);
 400                 priv->status = NULL;
 401         }
 402
 403         g_object_notify (G_OBJECT (idle), "state");
 404         g_object_notify (G_OBJECT (idle), "status");
 405 }
 406
 407 static void
 408 idle_session_idle_changed_cb (DBusGProxy  *gs_proxy,
 409                               gboolean     is_idle,
 410                               EmpathyIdle *idle)
 411 {
 412         EmpathyIdlePriv *priv;
 413
 414         priv = GET_PRIV (idle);
 415
 416         empathy_debug (DEBUG_DOMAIN, "Session idle state changed, %s -> %s",
 417                       priv->is_idle ? "yes" : "no",
 418                       is_idle ? "yes" : "no");
 419
 420         if (priv->state <= MC_PRESENCE_OFFLINE ||
 421             priv->state == MC_PRESENCE_HIDDEN) {
 422                 /* We are not online so nothing to do here */
 423                 priv->is_idle = is_idle;
 424                 return;
 425         }
 426
 427         if (is_idle && !priv->is_idle) {
 428                 McPresence new_state;
 429                 /* We are now idle */
 430
 431                 if (priv->state == MC_PRESENCE_AWAY ||
 432                            priv->state == MC_PRESENCE_EXTENDED_AWAY) {
 433                         /* User set away manually, when coming back we restore
 434                          * default presence. */
 435                         new_state = priv->state;
 436                         priv->saved_state = MC_PRESENCE_AVAILABLE;
 437                         priv->saved_status = NULL;
 438                 } else {
 439                         new_state = MC_PRESENCE_AWAY;
 440                         priv->saved_state = priv->state;
 441                         priv->saved_status = g_strdup (priv->status);
 442                 }
 443
 444                 empathy_debug (DEBUG_DOMAIN, "Going to autoaway");
 445                 empathy_idle_set_state (idle, new_state);
 446
 447                 idle_ext_away_start (idle);
 448         } else if (!is_idle && priv->is_idle) {
 449                 /* We are no more idle, restore state */
 450                 idle_ext_away_stop (idle);
 451
 452                 empathy_debug (DEBUG_DOMAIN, "Restoring state to %d %s",
 453                               priv->saved_state,
 454                               priv->saved_status);
 455
 456                 empathy_idle_set_presence (idle,
 457                                            priv->saved_state,
 458                                            priv->saved_status);
 459
 460                 g_free (priv->saved_status);
 461                 priv->saved_status = NULL;
 462         }
 463
 464         priv->is_idle = is_idle;
 465 }
 466
 467 static void
 468 idle_nm_state_change_cb (DBusGProxy  *proxy,
 469                          guint        state,
 470                          EmpathyIdle *idle)
 471 {
 472         EmpathyIdlePriv *priv;
 473
 474         priv = GET_PRIV (idle);
 475
 476         empathy_debug (DEBUG_DOMAIN, "New network state (%d)", state);
 477
 478         if (state != NM_STATE_CONNECTED &&
 479             priv->state > MC_PRESENCE_OFFLINE) {
 480                 /* We are no more connected */
 481                 idle_ext_away_stop (idle);
 482                 g_free (priv->saved_status);
 483                 priv->saved_state = priv->state;
 484                 priv->saved_status = g_strdup (priv->status);
 485
 486                 empathy_idle_set_state (idle, MC_PRESENCE_OFFLINE);
 487                 priv->nm_connected = FALSE;
 488         }
 489         else if (priv->state <= MC_PRESENCE_OFFLINE &&
 490                  state == NM_STATE_CONNECTED) {
 491                 /* We are now connected */
 492                 priv->nm_connected = TRUE;
 493                 empathy_idle_set_presence (idle,
 494                                            priv->saved_state,
 495                                            priv->saved_status);
 496         }
 497 }
 498
 499 static void
 500 idle_ext_away_start (EmpathyIdle *idle)
 501 {
 502         EmpathyIdlePriv *priv;
 503
 504         priv = GET_PRIV (idle);
 505
 506         idle_ext_away_stop (idle);
 507         priv->ext_away_timeout = g_timeout_add (EXT_AWAY_TIME * 1000,
 508                                                 (GSourceFunc) idle_ext_away_cb,
 509                                                 idle);
 510 }
 511
 512 static void
 513 idle_ext_away_stop (EmpathyIdle *idle)
 514 {
 515         EmpathyIdlePriv *priv;
 516
 517         priv = GET_PRIV (idle);
 518
 519         if (priv->ext_away_timeout) {
 520                 g_source_remove (priv->ext_away_timeout);
 521                 priv->ext_away_timeout = 0;
 522         }
 523 }
 524
 525 static gboolean
 526 idle_ext_away_cb (EmpathyIdle *idle)
 527 {
 528         EmpathyIdlePriv *priv;
 529
 530         priv = GET_PRIV (idle);
 531
 532         empathy_debug (DEBUG_DOMAIN, "Going to extended autoaway");
 533         empathy_idle_set_state (idle, MC_PRESENCE_EXTENDED_AWAY);
 534         priv->ext_away_timeout = 0;
 535
 536         return FALSE;
 537 }
 538