+++ /dev/null
-#!/usr/bin/env python
-
-import os
-import time
-import datetime
-import ConfigParser
-import logging
-
-import util.qt_compat as qt_compat
-QtCore = qt_compat.QtCore
-import dbus
-
-
-_FREMANTLE_ALARM = "Fremantle"
-_DIABLO_ALARM = "Diablo"
-_NO_ALARM = "None"
-
-
-try:
- import alarm
- ALARM_TYPE = _FREMANTLE_ALARM
-except (ImportError, OSError):
- try:
- import osso.alarmd as alarmd
- ALARM_TYPE = _DIABLO_ALARM
- except (ImportError, OSError):
- ALARM_TYPE = _NO_ALARM
-
-
-_moduleLogger = logging.getLogger(__name__)
-
-
-def _get_start_time(recurrence):
- now = datetime.datetime.now()
- startTimeMinute = now.minute + max(recurrence, 5) # being safe
- startTimeHour = now.hour + int(startTimeMinute / 60)
- startTimeMinute = startTimeMinute % 59
- now.replace(minute=startTimeMinute)
- timestamp = int(time.mktime(now.timetuple()))
- return timestamp
-
-
-def _create_recurrence_mask(recurrence, base):
- """
- >>> bin(_create_recurrence_mask(60, 60))
- '0b1'
- >>> bin(_create_recurrence_mask(30, 60))
- '0b1000000000000000000000000000001'
- >>> bin(_create_recurrence_mask(2, 60))
- '0b10101010101010101010101010101010101010101010101010101010101'
- >>> bin(_create_recurrence_mask(1, 60))
- '0b111111111111111111111111111111111111111111111111111111111111'
- """
- mask = 0
- for i in xrange(base / recurrence):
- mask |= 1 << (recurrence * i)
- return mask
-
-
-def _unpack_minutes(recurrence):
- """
- >>> _unpack_minutes(0)
- (0, 0, 0)
- >>> _unpack_minutes(1)
- (0, 0, 1)
- >>> _unpack_minutes(59)
- (0, 0, 59)
- >>> _unpack_minutes(60)
- (0, 1, 0)
- >>> _unpack_minutes(129)
- (0, 2, 9)
- >>> _unpack_minutes(5 * 60 * 24 + 3 * 60 + 2)
- (5, 3, 2)
- >>> _unpack_minutes(12 * 60 * 24 + 3 * 60 + 2)
- (5, 3, 2)
- """
- minutesInAnHour = 60
- minutesInDay = 24 * minutesInAnHour
- minutesInAWeek = minutesInDay * 7
-
- days = recurrence / minutesInDay
- daysOfWeek = days % 7
- recurrence -= days * minutesInDay
- hours = recurrence / minutesInAnHour
- recurrence -= hours * minutesInAnHour
- mins = recurrence % minutesInAnHour
- recurrence -= mins
- assert recurrence == 0, "Recurrence %d" % recurrence
- return daysOfWeek, hours, mins
-
-
-class _FremantleAlarmHandler(object):
-
- _INVALID_COOKIE = -1
- _REPEAT_FOREVER = -1
- _TITLE = "Dialcentral Notifications"
- _LAUNCHER = os.path.abspath(os.path.join(os.path.dirname(__file__), "alarm_notify.py"))
-
- def __init__(self):
- self._recurrence = 5
-
- self._alarmCookie = self._INVALID_COOKIE
- self._launcher = self._LAUNCHER
-
- def load_settings(self, config, sectionName):
- try:
- self._recurrence = config.getint(sectionName, "recurrence")
- self._alarmCookie = config.getint(sectionName, "alarmCookie")
- launcher = config.get(sectionName, "notifier")
- if launcher:
- self._launcher = launcher
- except ConfigParser.NoOptionError:
- pass
- except ConfigParser.NoSectionError:
- pass
-
- def save_settings(self, config, sectionName):
- try:
- config.set(sectionName, "recurrence", str(self._recurrence))
- config.set(sectionName, "alarmCookie", str(self._alarmCookie))
- launcher = self._launcher if self._launcher != self._LAUNCHER else ""
- config.set(sectionName, "notifier", launcher)
- except ConfigParser.NoOptionError:
- pass
- except ConfigParser.NoSectionError:
- pass
-
- def apply_settings(self, enabled, recurrence):
- if recurrence != self._recurrence or enabled != self.isEnabled:
- if self.isEnabled:
- self._clear_alarm()
- if enabled:
- self._set_alarm(recurrence)
- self._recurrence = int(recurrence)
-
- @property
- def recurrence(self):
- return self._recurrence
-
- @property
- def isEnabled(self):
- return self._alarmCookie != self._INVALID_COOKIE
-
- def _set_alarm(self, recurrenceMins):
- assert 1 <= recurrenceMins, "Notifications set to occur too frequently: %d" % recurrenceMins
- alarmTime = _get_start_time(recurrenceMins)
-
- event = alarm.Event()
- event.appid = self._TITLE
- event.alarm_time = alarmTime
- event.recurrences_left = self._REPEAT_FOREVER
-
- action = event.add_actions(1)[0]
- action.flags |= alarm.ACTION_TYPE_EXEC | alarm.ACTION_WHEN_TRIGGERED
- action.command = self._launcher
-
- recurrence = event.add_recurrences(1)[0]
- recurrence.mask_min |= _create_recurrence_mask(recurrenceMins, 60)
- recurrence.mask_hour |= alarm.RECUR_HOUR_DONTCARE
- recurrence.mask_mday |= alarm.RECUR_MDAY_DONTCARE
- recurrence.mask_wday |= alarm.RECUR_WDAY_DONTCARE
- recurrence.mask_mon |= alarm.RECUR_MON_DONTCARE
- recurrence.special |= alarm.RECUR_SPECIAL_NONE
-
- assert event.is_sane()
- self._alarmCookie = alarm.add_event(event)
-
- def _clear_alarm(self):
- if self._alarmCookie == self._INVALID_COOKIE:
- return
- alarm.delete_event(self._alarmCookie)
- self._alarmCookie = self._INVALID_COOKIE
-
-
-class _DiabloAlarmHandler(object):
-
- _INVALID_COOKIE = -1
- _TITLE = "Dialcentral Notifications"
- _LAUNCHER = os.path.abspath(os.path.join(os.path.dirname(__file__), "alarm_notify.py"))
- _REPEAT_FOREVER = -1
-
- def __init__(self):
- self._recurrence = 5
-
- bus = dbus.SystemBus()
- self._alarmdDBus = bus.get_object("com.nokia.alarmd", "/com/nokia/alarmd");
- self._alarmCookie = self._INVALID_COOKIE
- self._launcher = self._LAUNCHER
-
- def load_settings(self, config, sectionName):
- try:
- self._recurrence = config.getint(sectionName, "recurrence")
- self._alarmCookie = config.getint(sectionName, "alarmCookie")
- launcher = config.get(sectionName, "notifier")
- if launcher:
- self._launcher = launcher
- except ConfigParser.NoOptionError:
- pass
- except ConfigParser.NoSectionError:
- pass
-
- def save_settings(self, config, sectionName):
- config.set(sectionName, "recurrence", str(self._recurrence))
- config.set(sectionName, "alarmCookie", str(self._alarmCookie))
- launcher = self._launcher if self._launcher != self._LAUNCHER else ""
- config.set(sectionName, "notifier", launcher)
-
- def apply_settings(self, enabled, recurrence):
- if recurrence != self._recurrence or enabled != self.isEnabled:
- if self.isEnabled:
- self._clear_alarm()
- if enabled:
- self._set_alarm(recurrence)
- self._recurrence = int(recurrence)
-
- @property
- def recurrence(self):
- return self._recurrence
-
- @property
- def isEnabled(self):
- return self._alarmCookie != self._INVALID_COOKIE
-
- def _set_alarm(self, recurrence):
- assert 1 <= recurrence, "Notifications set to occur too frequently: %d" % recurrence
- alarmTime = _get_start_time(recurrence)
-
- #Setup the alarm arguments so that they can be passed to the D-Bus add_event method
- _DEFAULT_FLAGS = (
- alarmd.ALARM_EVENT_NO_DIALOG |
- alarmd.ALARM_EVENT_NO_SNOOZE |
- alarmd.ALARM_EVENT_CONNECTED
- )
- action = []
- action.extend(['flags', _DEFAULT_FLAGS])
- action.extend(['title', self._TITLE])
- action.extend(['path', self._launcher])
- action.extend([
- 'arguments',
- dbus.Array(
- [alarmTime, int(27)],
- signature=dbus.Signature('v')
- )
- ]) #int(27) used in place of alarm_index
-
- event = []
- event.extend([dbus.ObjectPath('/AlarmdEventRecurring'), dbus.UInt32(4)])
- event.extend(['action', dbus.ObjectPath('/AlarmdActionExec')]) #use AlarmdActionExec instead of AlarmdActionDbus
- event.append(dbus.UInt32(len(action) / 2))
- event.extend(action)
- event.extend(['time', dbus.Int64(alarmTime)])
- event.extend(['recurr_interval', dbus.UInt32(recurrence)])
- event.extend(['recurr_count', dbus.Int32(self._REPEAT_FOREVER)])
-
- self._alarmCookie = self._alarmdDBus.add_event(*event);
-
- def _clear_alarm(self):
- if self._alarmCookie == self._INVALID_COOKIE:
- return
- deleteResult = self._alarmdDBus.del_event(dbus.Int32(self._alarmCookie))
- self._alarmCookie = self._INVALID_COOKIE
- assert deleteResult != -1, "Deleting of alarm event failed"
-
-
-class _ApplicationAlarmHandler(object):
-
- _REPEAT_FOREVER = -1
- _MIN_TO_MS_FACTORY = 1000 * 60
-
- def __init__(self):
- self._timer = QtCore.QTimer()
- self._timer.setSingleShot(False)
- self._timer.setInterval(5 * self._MIN_TO_MS_FACTORY)
-
- def load_settings(self, config, sectionName):
- try:
- self._timer.setInterval(config.getint(sectionName, "recurrence") * self._MIN_TO_MS_FACTORY)
- except ConfigParser.NoOptionError:
- pass
- except ConfigParser.NoSectionError:
- pass
- self._timer.start()
-
- def save_settings(self, config, sectionName):
- config.set(sectionName, "recurrence", str(self.recurrence))
-
- def apply_settings(self, enabled, recurrence):
- self._timer.setInterval(recurrence * self._MIN_TO_MS_FACTORY)
- if enabled:
- self._timer.start()
- else:
- self._timer.stop()
-
- @property
- def notifySignal(self):
- return self._timer.timeout
-
- @property
- def recurrence(self):
- return int(self._timer.interval() / self._MIN_TO_MS_FACTORY)
-
- @property
- def isEnabled(self):
- return self._timer.isActive()
-
-
-class _NoneAlarmHandler(object):
-
- def __init__(self):
- self._enabled = False
- self._recurrence = 5
-
- def load_settings(self, config, sectionName):
- try:
- self._recurrence = config.getint(sectionName, "recurrence")
- self._enabled = True
- except ConfigParser.NoOptionError:
- pass
- except ConfigParser.NoSectionError:
- pass
-
- def save_settings(self, config, sectionName):
- config.set(sectionName, "recurrence", str(self.recurrence))
-
- def apply_settings(self, enabled, recurrence):
- self._enabled = enabled
-
- @property
- def recurrence(self):
- return self._recurrence
-
- @property
- def isEnabled(self):
- return self._enabled
-
-
-_BACKGROUND_ALARM_FACTORY = {
- _FREMANTLE_ALARM: _FremantleAlarmHandler,
- _DIABLO_ALARM: _DiabloAlarmHandler,
- _NO_ALARM: None,
-}[ALARM_TYPE]
-
-
-class AlarmHandler(object):
-
- ALARM_NONE = "No Alert"
- ALARM_BACKGROUND = "Background Alert"
- ALARM_APPLICATION = "Application Alert"
- ALARM_TYPES = [ALARM_NONE, ALARM_BACKGROUND, ALARM_APPLICATION]
-
- ALARM_FACTORY = {
- ALARM_NONE: _NoneAlarmHandler,
- ALARM_BACKGROUND: _BACKGROUND_ALARM_FACTORY,
- ALARM_APPLICATION: _ApplicationAlarmHandler,
- }
-
- def __init__(self):
- self._alarms = {self.ALARM_NONE: _NoneAlarmHandler()}
- self._currentAlarmType = self.ALARM_NONE
-
- def load_settings(self, config, sectionName):
- try:
- self._currentAlarmType = config.get(sectionName, "alarm")
- except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
- _moduleLogger.exception("Falling back to old style")
- self._currentAlarmType = self.ALARM_BACKGROUND
- if self._currentAlarmType not in self.ALARM_TYPES:
- self._currentAlarmType = self.ALARM_NONE
-
- self._init_alarm(self._currentAlarmType)
- if self._currentAlarmType in self._alarms:
- self._alarms[self._currentAlarmType].load_settings(config, sectionName)
- if not self._alarms[self._currentAlarmType].isEnabled:
- _moduleLogger.info("Config file lied, not actually enabled")
- self._currentAlarmType = self.ALARM_NONE
- else:
- _moduleLogger.info("Background alerts not supported")
- self._currentAlarmType = self.ALARM_NONE
-
- def save_settings(self, config, sectionName):
- config.set(sectionName, "alarm", self._currentAlarmType)
- self._alarms[self._currentAlarmType].save_settings(config, sectionName)
-
- def apply_settings(self, t, recurrence):
- self._init_alarm(t)
- newHandler = self._alarms[t]
- oldHandler = self._alarms[self._currentAlarmType]
- if newHandler != oldHandler:
- oldHandler.apply_settings(False, 0)
- newHandler.apply_settings(True, recurrence)
- self._currentAlarmType = t
-
- @property
- def alarmType(self):
- return self._currentAlarmType
-
- @property
- def backgroundNotificationsSupported(self):
- return self.ALARM_FACTORY[self.ALARM_BACKGROUND] is not None
-
- @property
- def applicationNotifySignal(self):
- self._init_alarm(self.ALARM_APPLICATION)
- return self._alarms[self.ALARM_APPLICATION].notifySignal
-
- @property
- def recurrence(self):
- return self._alarms[self._currentAlarmType].recurrence
-
- @property
- def isEnabled(self):
- return self._currentAlarmType != self.ALARM_NONE
-
- def _init_alarm(self, t):
- if t not in self._alarms and self.ALARM_FACTORY[t] is not None:
- self._alarms[t] = self.ALARM_FACTORY[t]()
-
-
-def main():
- logFormat = '(%(relativeCreated)5d) %(levelname)-5s %(threadName)s.%(name)s.%(funcName)s: %(message)s'
- logging.basicConfig(level=logging.DEBUG, format=logFormat)
- import constants
- try:
- import optparse
- except ImportError:
- return
-
- parser = optparse.OptionParser()
- parser.add_option("-x", "--display", action="store_true", dest="display", help="Display data")
- parser.add_option("-e", "--enable", action="store_true", dest="enabled", help="Whether the alarm should be enabled or not", default=False)
- parser.add_option("-d", "--disable", action="store_false", dest="enabled", help="Whether the alarm should be enabled or not", default=False)
- parser.add_option("-r", "--recurrence", action="store", type="int", dest="recurrence", help="How often the alarm occurs", default=5)
- (commandOptions, commandArgs) = parser.parse_args()
-
- alarmHandler = AlarmHandler()
- config = ConfigParser.SafeConfigParser()
- config.read(constants._user_settings_)
- alarmHandler.load_settings(config, "alarm")
-
- if commandOptions.display:
- print "Alarm (%s) is %s for every %d minutes" % (
- alarmHandler._alarmCookie,
- "enabled" if alarmHandler.isEnabled else "disabled",
- alarmHandler.recurrence,
- )
- else:
- isEnabled = commandOptions.enabled
- recurrence = commandOptions.recurrence
- alarmHandler.apply_settings(isEnabled, recurrence)
-
- alarmHandler.save_settings(config, "alarm")
- configFile = open(constants._user_settings_, "wb")
- try:
- config.write(configFile)
- finally:
- configFile.close()
-
-
-if __name__ == "__main__":
- main()
projects / gc-dialer / blobdiff