X-Git-Url: http://git.maemo.org/git/?p=gc-dialer;a=blobdiff_plain;f=src%2Fsession.py;h=f0fb9cfbd4b77a5c498a9cf82a490dfd22eac2ca;hp=ce7c0c1c9728d65825fcbe662875a36acdc3fbf6;hb=34273e81f9923688029cfea5aa8414ca1b1e73d0;hpb=41d98b8bd4ca7a54b3dc502bf9bce51072cb97a5 diff --git a/src/session.py b/src/session.py index ce7c0c1..f0fb9cf 100644 --- a/src/session.py +++ b/src/session.py @@ -15,6 +15,7 @@ except ImportError: from PyQt4 import QtCore from util import qore_utils +from util import qui_utils from util import concurrent from util import misc as misc_utils @@ -24,15 +25,6 @@ import constants _moduleLogger = logging.getLogger(__name__) -@contextlib.contextmanager -def notify_busy(log, message): - log.push_busy(message) - try: - yield - finally: - log.pop(message) - - class _DraftContact(object): def __init__(self, title, description, numbersWithDescriptions): @@ -60,15 +52,19 @@ class Draft(QtCore.QObject): self._contacts = {} self._pool = pool self._backend = backend + self._busyReason = None + self._message = "" - def send(self, text): + def send(self): assert 0 < len(self._contacts), "No contacts selected" + assert 0 < len(self._message), "No message to send" numbers = [misc_utils.make_ugly(contact.selectedNumber) for contact in self._contacts.itervalues()] le = concurrent.AsyncLinearExecution(self._pool, self._send) - le.start(numbers, text) + le.start(numbers, self._message) def call(self): assert len(self._contacts) == 1, "Must select 1 and only 1 contact" + assert len(self._message) == 0, "Cannot send message with call" (contact, ) = self._contacts.itervalues() number = misc_utils.make_ugly(contact.selectedNumber) le = concurrent.AsyncLinearExecution(self._pool, self._call) @@ -78,17 +74,25 @@ class Draft(QtCore.QObject): le = concurrent.AsyncLinearExecution(self._pool, self._cancel) le.start() + def _get_message(self): + return self._message + + def _set_message(self, message): + self._message = message + + message = property(_get_message, _set_message) + def add_contact(self, contactId, title, description, numbersWithDescriptions): - if contactId in self._contacts: - _moduleLogger.info("Adding duplicate contact %r" % contactId) - # @todo Remove this evil hack to re-popup the dialog - self.recipientsChanged.emit() - return + if self._busyReason is not None: + raise RuntimeError("Please wait for %r" % self._busyReason) + # Allow overwriting of contacts so that the message can be updated and the SMS dialog popped back up contactDetails = _DraftContact(title, description, numbersWithDescriptions) self._contacts[contactId] = contactDetails self.recipientsChanged.emit() def remove_contact(self, contactId): + if self._busyReason is not None: + raise RuntimeError("Please wait for %r" % self._busyReason) assert contactId in self._contacts, "Contact missing" del self._contacts[contactId] self.recipientsChanged.emit() @@ -118,43 +122,63 @@ class Draft(QtCore.QObject): self._contacts[cid].selectedNumber = number def clear(self): + if self._busyReason is not None: + raise RuntimeError("Please wait for %r" % self._busyReason) + self._clear() + + def _clear(self): oldContacts = self._contacts self._contacts = {} + self._message = "" if oldContacts: self.recipientsChanged.emit() + @contextlib.contextmanager + def _busy(self, message): + if self._busyReason is not None: + raise RuntimeError("Already busy doing %r" % self._busyReason) + try: + self._busyReason = message + yield + finally: + self._busyReason = None + def _send(self, numbers, text): self.sendingMessage.emit() try: - with notify_busy(self._errorLog, "Sending Text"): - yield ( - self._backend[0].send_sms, - (numbers, text), - {}, - ) - self.sentMessage.emit() - self.clear() + with self._busy("Sending Text"): + with qui_utils.notify_busy(self._errorLog, "Sending Text"): + yield ( + self._backend[0].send_sms, + (numbers, text), + {}, + ) + self.sentMessage.emit() + self._clear() except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) def _call(self, number): self.calling.emit() try: - with notify_busy(self._errorLog, "Calling"): - yield ( - self._backend[0].call, - (number, ), - {}, - ) - self.called.emit() - self.clear() + with self._busy("Calling"): + with qui_utils.notify_busy(self._errorLog, "Calling"): + yield ( + self._backend[0].call, + (number, ), + {}, + ) + self.called.emit() + self._clear() except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) def _cancel(self): self.cancelling.emit() try: - with notify_busy(self._errorLog, "Cancelling"): + with qui_utils.notify_busy(self._errorLog, "Cancelling"): yield ( self._backend[0].cancel, (), @@ -162,12 +186,14 @@ class Draft(QtCore.QObject): ) self.cancelled.emit() except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) class Session(QtCore.QObject): # @todo Somehow add support for csv contacts + # @BUG When loading without caches, downloads messages twice stateChange = QtCore.pyqtSignal(str) loggedOut = QtCore.pyqtSignal() @@ -222,7 +248,7 @@ class Session(QtCore.QObject): return self._draft def login(self, username, password): - assert self.state == self.LOGGEDOUT_STATE, "Can only log-in when logged out" + assert self.state == self.LOGGEDOUT_STATE, "Can only log-in when logged out (currently %s" % self.state assert username != "", "No username specified" if self._cachePath is not None: cookiePath = os.path.join(self._cachePath, "%s.cookies" % username) @@ -239,24 +265,30 @@ class Session(QtCore.QObject): le.start(username, password) def logout(self): - assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in" + assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in (currently %s" % self.state + _moduleLogger.info("Logging out") self._pool.stop() self._loggedInTime = self._LOGGEDOUT_TIME self._backend[0].persist() self._save_to_cache() + self.stateChange.emit(self.LOGGEDOUT_STATE) + self.loggedOut.emit() def clear(self): - assert self.state == self.LOGGEDOUT_STATE, "Can only clear when logged out" + assert self.state == self.LOGGEDOUT_STATE, "Can only clear when logged out (currently %s" % self.state self._backend[0].logout() del self._backend[0] self._clear_cache() self._draft.clear() def logout_and_clear(self): - assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in" + assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in (currently %s" % self.state + _moduleLogger.info("Logging out and clearing the account") self._pool.stop() self._loggedInTime = self._LOGGEDOUT_TIME self.clear() + self.stateChange.emit(self.LOGGEDOUT_STATE) + self.loggedOut.emit() def update_contacts(self, force = True): if not force and self._contacts: @@ -303,18 +335,17 @@ class Session(QtCore.QObject): le.start(dnd) def _set_dnd(self, dnd): - # I'm paranoid about our state geting out of sync so we set no matter - # what but act as if we have the cannonical state - assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in" oldDnd = self._dnd try: - with notify_busy(self._errorLog, "Setting DND Status"): + assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state + with qui_utils.notify_busy(self._errorLog, "Setting DND Status"): yield ( self._backend[0].set_dnd, (dnd, ), {}, ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return self._dnd = dnd @@ -325,10 +356,13 @@ class Session(QtCore.QObject): return self._dnd def get_account_number(self): + if self.state != self.LOGGEDIN_STATE: + return "" return self._backend[0].get_account_number() def get_callback_numbers(self): - # @todo Remove evilness (might call is_authed which can block) + if self.state != self.LOGGEDIN_STATE: + return {} return self._backend[0].get_callback_numbers() def get_callback_number(self): @@ -339,18 +373,16 @@ class Session(QtCore.QObject): le.start(callback) def _set_callback_number(self, callback): - # I'm paranoid about our state geting out of sync so we set no matter - # what but act as if we have the cannonical state - assert self.state == self.LOGGEDIN_STATE, "Callbacks configurable only when logged in" oldCallback = self._callback try: - with notify_busy(self._errorLog, "Setting Callback"): - yield ( - self._backend[0].set_callback_number, - (callback, ), - {}, - ) + assert self.state == self.LOGGEDIN_STATE, "Callbacks configurable only when logged in (currently %s" % self.state + yield ( + self._backend[0].set_callback_number, + (callback, ), + {}, + ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return self._callback = callback @@ -358,13 +390,12 @@ class Session(QtCore.QObject): self.callbackNumberChanged.emit(self._callback) def _login(self, username, password): - with notify_busy(self._errorLog, "Logging In"): + with qui_utils.notify_busy(self._errorLog, "Logging In"): self._loggedInTime = self._LOGGINGIN_TIME self.stateChange.emit(self.LOGGINGIN_STATE) finalState = self.LOGGEDOUT_STATE + isLoggedIn = False try: - isLoggedIn = False - if not isLoggedIn and self._backend[0].is_quick_login_possible(): isLoggedIn = yield ( self._backend[0].is_authed, @@ -401,6 +432,8 @@ class Session(QtCore.QObject): needOps = True self.loggedIn.emit() + self.stateChange.emit(finalState) + finalState = None # Mark it as already set if needOps: loginOps = self._loginOps[:] @@ -409,11 +442,18 @@ class Session(QtCore.QObject): del self._loginOps[:] for asyncOp in loginOps: asyncOp.start() + else: + self._loggedInTime = self._LOGGEDOUT_TIME + self.error.emit("Error logging in") except Exception, e: self._loggedInTime = self._LOGGEDOUT_TIME + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) finally: - self.stateChange.emit(finalState) + if finalState is not None: + self.stateChange.emit(finalState) + if isLoggedIn and self._callback: + self.set_callback_number(self._callback) def _load(self): updateContacts = len(self._contacts) != 0 @@ -462,13 +502,19 @@ class Session(QtCore.QObject): _moduleLogger.exception("Weirdness loading") return False - ( - version, build, - contacts, contactUpdateTime, - messages, messageUpdateTime, - history, historyUpdateTime, - dnd, callback - ) = dumpedData + try: + ( + version, build, + contacts, contactUpdateTime, + messages, messageUpdateTime, + history, historyUpdateTime, + dnd, callback + ) = dumpedData + except ValueError: + _moduleLogger.exception("Upgrade/downgrade fun") + return False + except: + _moduleLogger.exception("Weirdlings") if misc_utils.compare_versions( self._OLDEST_COMPATIBLE_FORMAT_VERSION, @@ -520,11 +566,11 @@ class Session(QtCore.QObject): oldCallback = self._callback self._contacts = {} - self._contactUpdateTime = datetime.datetime(1, 1, 1) + self._contactUpdateTime = datetime.datetime(1971, 1, 1) self._messages = [] - self._messageUpdateTime = datetime.datetime(1, 1, 1) + self._messageUpdateTime = datetime.datetime(1971, 1, 1) self._history = [] - self._historyUpdateTime = datetime.datetime(1, 1, 1) + self._historyUpdateTime = datetime.datetime(1971, 1, 1) self._dnd = False self._callback = "" @@ -543,13 +589,15 @@ class Session(QtCore.QObject): def _update_contacts(self): try: - with notify_busy(self._errorLog, "Updating Contacts"): + assert self.state == self.LOGGEDIN_STATE, "Contacts requires being logged in (currently %s" % self.state + with qui_utils.notify_busy(self._errorLog, "Updating Contacts"): self._contacts = yield ( self._backend[0].get_contacts, (), {}, ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return self._contactUpdateTime = datetime.datetime.now() @@ -557,13 +605,15 @@ class Session(QtCore.QObject): def _update_messages(self): try: - with notify_busy(self._errorLog, "Updating Messages"): + assert self.state == self.LOGGEDIN_STATE, "Messages requires being logged in (currently %s" % self.state + with qui_utils.notify_busy(self._errorLog, "Updating Messages"): self._messages = yield ( self._backend[0].get_messages, (), {}, ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return self._messageUpdateTime = datetime.datetime.now() @@ -571,13 +621,15 @@ class Session(QtCore.QObject): def _update_history(self): try: - with notify_busy(self._errorLog, "Updating History"): + assert self.state == self.LOGGEDIN_STATE, "History requires being logged in (currently %s" % self.state + with qui_utils.notify_busy(self._errorLog, "Updating History"): self._history = yield ( self._backend[0].get_recent, (), {}, ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return self._historyUpdateTime = datetime.datetime.now() @@ -586,12 +638,14 @@ class Session(QtCore.QObject): def _update_dnd(self): oldDnd = self._dnd try: + assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state self._dnd = yield ( self._backend[0].is_dnd, (), {}, ) except Exception, e: + _moduleLogger.exception("Reporting error to user") self.error.emit(str(e)) return if oldDnd != self._dnd: