git.maemo.org Git - gc-dialer/blob - dialcentral/alarm_handler.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import with_statement
   4
   5 import os
   6 import time
   7 import datetime
   8 import ConfigParser
   9 import logging
  10
  11 import dbus
  12
  13 import dialcentral.util.qt_compat as qt_compat
  14 QtCore = qt_compat.QtCore
  15 import dialcentral.util.linux as linux_utils
  16
  17
  18 _FREMANTLE_ALARM = "Fremantle"
  19 _DIABLO_ALARM = "Diablo"
  20 _NO_ALARM = "None"
  21
  22
  23 try:
  24         import alarm
  25         ALARM_TYPE = _FREMANTLE_ALARM
  26 except (ImportError, OSError):
  27         try:
  28                 import osso.alarmd as alarmd
  29                 ALARM_TYPE = _DIABLO_ALARM
  30         except (ImportError, OSError):
  31                 ALARM_TYPE = _NO_ALARM
  32
  33
  34 _moduleLogger = logging.getLogger(__name__)
  35
  36
  37 def _get_start_time(recurrence):
  38         now = datetime.datetime.now()
  39         startTimeMinute = now.minute + max(recurrence, 5) # being safe
  40         startTimeHour = now.hour + int(startTimeMinute / 60)
  41         startTimeMinute = startTimeMinute % 59
  42         now.replace(minute=startTimeMinute)
  43         timestamp = int(time.mktime(now.timetuple()))
  44         return timestamp
  45
  46
  47 def _create_recurrence_mask(recurrence, base):
  48         """
  49         >>> bin(_create_recurrence_mask(60, 60))
  50         '0b1'
  51         >>> bin(_create_recurrence_mask(30, 60))
  52         '0b1000000000000000000000000000001'
  53         >>> bin(_create_recurrence_mask(2, 60))
  54         '0b10101010101010101010101010101010101010101010101010101010101'
  55         >>> bin(_create_recurrence_mask(1, 60))
  56         '0b111111111111111111111111111111111111111111111111111111111111'
  57         """
  58         mask = 0
  59         for i in xrange(base / recurrence):
  60                 mask |= 1 << (recurrence * i)
  61         return mask
  62
  63
  64 def _unpack_minutes(recurrence):
  65         """
  66         >>> _unpack_minutes(0)
  67         (0, 0, 0)
  68         >>> _unpack_minutes(1)
  69         (0, 0, 1)
  70         >>> _unpack_minutes(59)
  71         (0, 0, 59)
  72         >>> _unpack_minutes(60)
  73         (0, 1, 0)
  74         >>> _unpack_minutes(129)
  75         (0, 2, 9)
  76         >>> _unpack_minutes(5 * 60 * 24 + 3 * 60 + 2)
  77         (5, 3, 2)
  78         >>> _unpack_minutes(12 * 60 * 24 + 3 * 60 + 2)
  79         (5, 3, 2)
  80         """
  81         minutesInAnHour = 60
  82         minutesInDay = 24 * minutesInAnHour
  83         minutesInAWeek = minutesInDay * 7
  84
  85         days = recurrence / minutesInDay
  86         daysOfWeek = days % 7
  87         recurrence -= days * minutesInDay
  88         hours = recurrence / minutesInAnHour
  89         recurrence -= hours * minutesInAnHour
  90         mins = recurrence % minutesInAnHour
  91         recurrence -= mins
  92         assert recurrence == 0, "Recurrence %d" % recurrence
  93         return daysOfWeek, hours, mins
  94
  95
  96 class _FremantleAlarmHandler(object):
  97
  98         _INVALID_COOKIE = -1
  99         _REPEAT_FOREVER = -1
 100         _TITLE = "Dialcentral Notifications"
 101         _LAUNCHER = "python %s" % os.path.abspath(os.path.join(os.path.dirname(__file__), "alarm_notify.py"))
 102
 103         def __init__(self):
 104                 self._recurrence = 5
 105
 106                 self._alarmCookie = self._INVALID_COOKIE
 107                 self._launcher = self._LAUNCHER
 108
 109         def load_settings(self, config, sectionName):
 110                 try:
 111                         self._recurrence = config.getint(sectionName, "recurrence")
 112                         self._alarmCookie = config.getint(sectionName, "alarmCookie")
 113                         launcher = config.get(sectionName, "notifier")
 114                         if launcher:
 115                                 self._launcher = launcher
 116                 except ConfigParser.NoOptionError:
 117                         pass
 118                 except ConfigParser.NoSectionError:
 119                         pass
 120
 121         def save_settings(self, config, sectionName):
 122                 try:
 123                         config.set(sectionName, "recurrence", str(self._recurrence))
 124                         config.set(sectionName, "alarmCookie", str(self._alarmCookie))
 125                         launcher = self._launcher if self._launcher != self._LAUNCHER else ""
 126                         config.set(sectionName, "notifier", launcher)
 127                 except ConfigParser.NoOptionError:
 128                         pass
 129                 except ConfigParser.NoSectionError:
 130                         pass
 131
 132         def apply_settings(self, enabled, recurrence):
 133                 if recurrence != self._recurrence or enabled != self.isEnabled:
 134                         if self.isEnabled:
 135                                 self._clear_alarm()
 136                         if enabled:
 137                                 self._set_alarm(recurrence)
 138                 self._recurrence = int(recurrence)
 139
 140         @property
 141         def recurrence(self):
 142                 return self._recurrence
 143
 144         @property
 145         def isEnabled(self):
 146                 return self._alarmCookie != self._INVALID_COOKIE
 147
 148         def _set_alarm(self, recurrenceMins):
 149                 assert 1 <= recurrenceMins, "Notifications set to occur too frequently: %d" % recurrenceMins
 150                 alarmTime = _get_start_time(recurrenceMins)
 151
 152                 event = alarm.Event()
 153                 event.appid = self._TITLE
 154                 event.alarm_time = alarmTime
 155                 event.recurrences_left = self._REPEAT_FOREVER
 156
 157                 action = event.add_actions(1)[0]
 158                 action.flags |= alarm.ACTION_TYPE_EXEC | alarm.ACTION_WHEN_TRIGGERED
 159                 action.command = self._launcher
 160
 161                 recurrence = event.add_recurrences(1)[0]
 162                 recurrence.mask_min |= _create_recurrence_mask(recurrenceMins, 60)
 163                 recurrence.mask_hour |= alarm.RECUR_HOUR_DONTCARE
 164                 recurrence.mask_mday |= alarm.RECUR_MDAY_DONTCARE
 165                 recurrence.mask_wday |= alarm.RECUR_WDAY_DONTCARE
 166                 recurrence.mask_mon |= alarm.RECUR_MON_DONTCARE
 167                 recurrence.special |= alarm.RECUR_SPECIAL_NONE
 168
 169                 assert event.is_sane()
 170                 self._alarmCookie = alarm.add_event(event)
 171
 172         def _clear_alarm(self):
 173                 if self._alarmCookie == self._INVALID_COOKIE:
 174                         return
 175                 alarm.delete_event(self._alarmCookie)
 176                 self._alarmCookie = self._INVALID_COOKIE
 177
 178
 179 class _DiabloAlarmHandler(object):
 180
 181         _INVALID_COOKIE = -1
 182         _TITLE = "Dialcentral Notifications"
 183         _LAUNCHER = "python %s" % os.path.abspath(os.path.join(os.path.dirname(__file__), "alarm_notify.py"))
 184         _REPEAT_FOREVER = -1
 185
 186         def __init__(self):
 187                 self._recurrence = 5
 188
 189                 bus = dbus.SystemBus()
 190                 self._alarmdDBus = bus.get_object("com.nokia.alarmd", "/com/nokia/alarmd");
 191                 self._alarmCookie = self._INVALID_COOKIE
 192                 self._launcher = self._LAUNCHER
 193
 194         def load_settings(self, config, sectionName):
 195                 try:
 196                         self._recurrence = config.getint(sectionName, "recurrence")
 197                         self._alarmCookie = config.getint(sectionName, "alarmCookie")
 198                         launcher = config.get(sectionName, "notifier")
 199                         if launcher:
 200                                 self._launcher = launcher
 201                 except ConfigParser.NoOptionError:
 202                         pass
 203                 except ConfigParser.NoSectionError:
 204                         pass
 205
 206         def save_settings(self, config, sectionName):
 207                 config.set(sectionName, "recurrence", str(self._recurrence))
 208                 config.set(sectionName, "alarmCookie", str(self._alarmCookie))
 209                 launcher = self._launcher if self._launcher != self._LAUNCHER else ""
 210                 config.set(sectionName, "notifier", launcher)
 211
 212         def apply_settings(self, enabled, recurrence):
 213                 if recurrence != self._recurrence or enabled != self.isEnabled:
 214                         if self.isEnabled:
 215                                 self._clear_alarm()
 216                         if enabled:
 217                                 self._set_alarm(recurrence)
 218                 self._recurrence = int(recurrence)
 219
 220         @property
 221         def recurrence(self):
 222                 return self._recurrence
 223
 224         @property
 225         def isEnabled(self):
 226                 return self._alarmCookie != self._INVALID_COOKIE
 227
 228         def _set_alarm(self, recurrence):
 229                 assert 1 <= recurrence, "Notifications set to occur too frequently: %d" % recurrence
 230                 alarmTime = _get_start_time(recurrence)
 231
 232                 #Setup the alarm arguments so that they can be passed to the D-Bus add_event method
 233                 _DEFAULT_FLAGS = (
 234                         alarmd.ALARM_EVENT_NO_DIALOG |
 235                         alarmd.ALARM_EVENT_NO_SNOOZE |
 236                         alarmd.ALARM_EVENT_CONNECTED
 237                 )
 238                 action = []
 239                 action.extend(['flags', _DEFAULT_FLAGS])
 240                 action.extend(['title', self._TITLE])
 241                 action.extend(['path', self._launcher])
 242                 action.extend([
 243                         'arguments',
 244                         dbus.Array(
 245                                 [alarmTime, int(27)],
 246                                 signature=dbus.Signature('v')
 247                         )
 248                 ])  #int(27) used in place of alarm_index
 249
 250                 event = []
 251                 event.extend([dbus.ObjectPath('/AlarmdEventRecurring'), dbus.UInt32(4)])
 252                 event.extend(['action', dbus.ObjectPath('/AlarmdActionExec')])  #use AlarmdActionExec instead of AlarmdActionDbus
 253                 event.append(dbus.UInt32(len(action) / 2))
 254                 event.extend(action)
 255                 event.extend(['time', dbus.Int64(alarmTime)])
 256                 event.extend(['recurr_interval', dbus.UInt32(recurrence)])
 257                 event.extend(['recurr_count', dbus.Int32(self._REPEAT_FOREVER)])
 258
 259                 self._alarmCookie = self._alarmdDBus.add_event(*event);
 260
 261         def _clear_alarm(self):
 262                 if self._alarmCookie == self._INVALID_COOKIE:
 263                         return
 264                 deleteResult = self._alarmdDBus.del_event(dbus.Int32(self._alarmCookie))
 265                 self._alarmCookie = self._INVALID_COOKIE
 266                 assert deleteResult != -1, "Deleting of alarm event failed"
 267
 268
 269 class _ApplicationAlarmHandler(object):
 270
 271         _REPEAT_FOREVER = -1
 272         _MIN_TO_MS_FACTORY = 1000 * 60
 273
 274         def __init__(self):
 275                 self._timer = QtCore.QTimer()
 276                 self._timer.setSingleShot(False)
 277                 self._timer.setInterval(5 * self._MIN_TO_MS_FACTORY)
 278
 279         def load_settings(self, config, sectionName):
 280                 try:
 281                         self._timer.setInterval(config.getint(sectionName, "recurrence") * self._MIN_TO_MS_FACTORY)
 282                 except ConfigParser.NoOptionError:
 283                         pass
 284                 except ConfigParser.NoSectionError:
 285                         pass
 286                 self._timer.start()
 287
 288         def save_settings(self, config, sectionName):
 289                 config.set(sectionName, "recurrence", str(self.recurrence))
 290
 291         def apply_settings(self, enabled, recurrence):
 292                 self._timer.setInterval(recurrence * self._MIN_TO_MS_FACTORY)
 293                 if enabled:
 294                         self._timer.start()
 295                 else:
 296                         self._timer.stop()
 297
 298         @property
 299         def notifySignal(self):
 300                 return self._timer.timeout
 301
 302         @property
 303         def recurrence(self):
 304                 return int(self._timer.interval() / self._MIN_TO_MS_FACTORY)
 305
 306         @property
 307         def isEnabled(self):
 308                 return self._timer.isActive()
 309
 310
 311 class _NoneAlarmHandler(object):
 312
 313         def __init__(self):
 314                 self._enabled = False
 315                 self._recurrence = 5
 316
 317         def load_settings(self, config, sectionName):
 318                 try:
 319                         self._recurrence = config.getint(sectionName, "recurrence")
 320                         self._enabled = True
 321                 except ConfigParser.NoOptionError:
 322                         pass
 323                 except ConfigParser.NoSectionError:
 324                         pass
 325
 326         def save_settings(self, config, sectionName):
 327                 config.set(sectionName, "recurrence", str(self.recurrence))
 328
 329         def apply_settings(self, enabled, recurrence):
 330                 self._enabled = enabled
 331
 332         @property
 333         def recurrence(self):
 334                 return self._recurrence
 335
 336         @property
 337         def isEnabled(self):
 338                 return self._enabled
 339
 340
 341 _BACKGROUND_ALARM_FACTORY = {
 342         _FREMANTLE_ALARM: _FremantleAlarmHandler,
 343         _DIABLO_ALARM: _DiabloAlarmHandler,
 344         _NO_ALARM: None,
 345 }[ALARM_TYPE]
 346
 347
 348 class AlarmHandler(object):
 349
 350         ALARM_NONE = "No Alert"
 351         ALARM_BACKGROUND = "Background Alert"
 352         ALARM_APPLICATION = "Application Alert"
 353         ALARM_TYPES = [ALARM_NONE, ALARM_BACKGROUND, ALARM_APPLICATION]
 354
 355         ALARM_FACTORY = {
 356                 ALARM_NONE: _NoneAlarmHandler,
 357                 ALARM_BACKGROUND: _BACKGROUND_ALARM_FACTORY,
 358                 ALARM_APPLICATION: _ApplicationAlarmHandler,
 359         }
 360
 361         def __init__(self):
 362                 self._alarms = {self.ALARM_NONE: _NoneAlarmHandler()}
 363                 self._currentAlarmType = self.ALARM_NONE
 364
 365         def load_settings(self, config, sectionName):
 366                 try:
 367                         self._currentAlarmType = config.get(sectionName, "alarm")
 368                 except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
 369                         _moduleLogger.exception("Falling back to old style")
 370                         self._currentAlarmType = self.ALARM_BACKGROUND
 371                 if self._currentAlarmType not in self.ALARM_TYPES:
 372                         self._currentAlarmType = self.ALARM_NONE
 373
 374                 self._init_alarm(self._currentAlarmType)
 375                 if self._currentAlarmType in self._alarms:
 376                         self._alarms[self._currentAlarmType].load_settings(config, sectionName)
 377                         if not self._alarms[self._currentAlarmType].isEnabled:
 378                                 _moduleLogger.info("Config file lied, not actually enabled")
 379                                 self._currentAlarmType = self.ALARM_NONE
 380                 else:
 381                         _moduleLogger.info("Background alerts not supported")
 382                         self._currentAlarmType = self.ALARM_NONE
 383
 384         def save_settings(self, config, sectionName):
 385                 config.set(sectionName, "alarm", self._currentAlarmType)
 386                 self._alarms[self._currentAlarmType].save_settings(config, sectionName)
 387
 388         def apply_settings(self, t, recurrence):
 389                 self._init_alarm(t)
 390                 newHandler = self._alarms[t]
 391                 oldHandler = self._alarms[self._currentAlarmType]
 392                 if newHandler != oldHandler:
 393                         oldHandler.apply_settings(False, 0)
 394                 newHandler.apply_settings(True, recurrence)
 395                 self._currentAlarmType = t
 396
 397         @property
 398         def alarmType(self):
 399                 return self._currentAlarmType
 400
 401         @property
 402         def backgroundNotificationsSupported(self):
 403                 return self.ALARM_FACTORY[self.ALARM_BACKGROUND] is not None
 404
 405         @property
 406         def applicationNotifySignal(self):
 407                 self._init_alarm(self.ALARM_APPLICATION)
 408                 return self._alarms[self.ALARM_APPLICATION].notifySignal
 409
 410         @property
 411         def recurrence(self):
 412                 return self._alarms[self._currentAlarmType].recurrence
 413
 414         @property
 415         def isEnabled(self):
 416                 return self._currentAlarmType != self.ALARM_NONE
 417
 418         def _init_alarm(self, t):
 419                 if t not in self._alarms and self.ALARM_FACTORY[t] is not None:
 420                         self._alarms[t] = self.ALARM_FACTORY[t]()
 421
 422
 423 def main():
 424         logFormat = '(%(relativeCreated)5d) %(levelname)-5s %(threadName)s.%(name)s.%(funcName)s: %(message)s'
 425         logging.basicConfig(level=logging.DEBUG, format=logFormat)
 426         from dialcentral import constants
 427         try:
 428                 import optparse
 429         except ImportError:
 430                 return
 431
 432         parser = optparse.OptionParser()
 433         parser.add_option("-x", "--display", action="store_true", dest="display", help="Display data")
 434         parser.add_option("-e", "--enable", action="store_true", dest="enabled", help="Whether the alarm should be enabled or not", default=False)
 435         parser.add_option("-d", "--disable", action="store_false", dest="enabled", help="Whether the alarm should be enabled or not", default=False)
 436         parser.add_option("-r", "--recurrence", action="store", type="int", dest="recurrence", help="How often the alarm occurs", default=5)
 437         (commandOptions, commandArgs) = parser.parse_args()
 438
 439         settingsPath = linux_utils.get_resource_path("config", constants.__app_name__, "settings.ini")
 440
 441         alarmHandler = AlarmHandler()
 442         config = ConfigParser.SafeConfigParser()
 443         config.read(settingsPath)
 444         alarmHandler.load_settings(config, "alarm")
 445
 446         if commandOptions.display:
 447                 print "Alarm (%s) is %s for every %d minutes" % (
 448                         alarmHandler._alarmCookie,
 449                         "enabled" if alarmHandler.isEnabled else "disabled",
 450                         alarmHandler.recurrence,
 451                 )
 452         else:
 453                 isEnabled = commandOptions.enabled
 454                 recurrence = commandOptions.recurrence
 455                 alarmHandler.apply_settings(AlarmHandler.ALARM_BACKGROUND if isEnabled else AlarmHandler.ALARM_NONE, recurrence)
 456
 457                 alarmHandler.save_settings(config, "alarm")
 458                 with open(settingsPath, "wb") as configFile:
 459                         config.write(configFile)
 460
 461
 462 if __name__ == "__main__":
 463         main()