X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fconnection.py;h=080c6214e63cc0bf6ee2c4925cd1d3a07eac5731;hp=80518cc43777ee280f35575baf9e088094711525;hb=82d3b4a7ae787eaaf1ac5ff07bc60aa25c84d50a;hpb=8559724ac27bfbfd4711ef952a0f6de038017c2c diff --git a/src/connection.py b/src/connection.py index 80518cc..080c621 100644 --- a/src/connection.py +++ b/src/connection.py @@ -6,7 +6,6 @@ import telepathy import constants import tp -import util.go_utils as gobject_utils import util.misc as misc_utils import gvoice @@ -86,6 +85,8 @@ class TheOneRingConnection( @misc_utils.log_exception(_moduleLogger) def __init__(self, manager, parameters): + self._loggers = [] + self.check_parameters(parameters) account = unicode(parameters['account']) encodedAccount = parameters['account'].encode('utf-8') @@ -97,7 +98,7 @@ class TheOneRingConnection( # Connection init must come first self.__options = TheOneRingOptions(parameters) self.__session = gvoice.session.Session( - cookiePath = None, + cookiePath = os.path.join(constants._data_path_, "%s.cookies" % account), defaults = { "contacts": (self.__options.contactsPollPeriodInHours, "hours"), "voicemail": (self.__options.voicemailPollPeriodInMinutes, "minutes"), @@ -138,10 +139,12 @@ class TheOneRingConnection( autogv.NewGVConversations(weakref.ref(self)), autogv.RefreshVoicemail(weakref.ref(self)), autogv.AutoDisconnect(weakref.ref(self)), + autogv.DelayEnableContactIntegration(constants._telepathy_implementation_name_), ] - self._delayedConnect = gobject_utils.Async(self._delayed_connect) _moduleLogger.info("Connection to the account %s created" % account) + self._timedDisconnect = autogv.TimedDisconnect(weakref.ref(self)) + self._timedDisconnect.start() @property def manager(self): @@ -165,17 +168,38 @@ class TheOneRingConnection( def get_handle_by_name(self, handleType, handleName): requestedHandleName = handleName.encode('utf-8') + + # We need to return an existing or create a new handle. Unfortunately + # handle init's take care of normalizing the handle name. So we have + # to create a new handle regardless and burn some handle id's and burn + # some extra memory of creating objects we throw away if the handle + # already exists. if handleType == telepathy.HANDLE_TYPE_CONTACT: - _moduleLogger.debug("get_handle_by_name Contact: %s" % requestedHandleName) h = handle.create_handle(self, 'contact', requestedHandleName) elif handleType == telepathy.HANDLE_TYPE_LIST: # Support only server side (immutable) lists - _moduleLogger.debug("get_handle_by_name List: %s" % requestedHandleName) h = handle.create_handle(self, 'list', requestedHandleName) else: raise telepathy.errors.NotAvailable('Handle type unsupported %d' % handleType) + + for candidate in self._handles.itervalues(): + if candidate.get_name() == h.get_name(): + h = candidate + _moduleLogger.debug("Re-used handle for %s, I hoped this helped" % handleName) + break + return h + def log_to_user(self, component, message): + for logger in self._loggers: + logger.log_message(component, message) + + def add_logger(self, logger): + self._loggers.append(logger) + + def remove_logger(self, logger): + self._loggers.remove(logger) + @property def _channel_manager(self): return self.__channelManager @@ -188,22 +212,27 @@ class TheOneRingConnection( if self._status != telepathy.CONNECTION_STATUS_DISCONNECTED: _moduleLogger.info("Attempting connect when not disconnected") return - _moduleLogger.info("Kicking off connect") - self._delayedConnect.start() - - @misc_utils.log_exception(_moduleLogger) - def _delayed_connect(self): _moduleLogger.info("Connecting...") self.StatusChanged( telepathy.CONNECTION_STATUS_CONNECTING, telepathy.CONNECTION_STATUS_REASON_REQUESTED ) + self._timedDisconnect.stop() + self.session.login( + self.__credentials[0], + self.__credentials[1], + self._on_login, + self._on_login_error, + ) + + @misc_utils.log_exception(_moduleLogger) + def _on_login(self, *args): + _moduleLogger.info("Connected, setting up...") try: self.__session.load(self.__cachePath) for plumber in self._plumbing: plumber.start() - self.session.login(*self.__credentials) if not self.__callbackNumberParameter: callback = gvoice.backend.get_sane_callback( self.session.backend @@ -217,22 +246,28 @@ class TheOneRingConnection( publishHandle = self.get_handle_by_name(telepathy.HANDLE_TYPE_LIST, "publish") publishProps = self.generate_props(telepathy.CHANNEL_TYPE_CONTACT_LIST, publishHandle, False) self.__channelManager.channel_for_props(publishProps, signal=True) - except gvoice.backend.NetworkError: - _moduleLogger.exception("Connection Failed") - self.disconnect(telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR) - return except Exception: - _moduleLogger.exception("Connection Failed") + _moduleLogger.exception("Setup failed") self.disconnect(telepathy.CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED) return - _moduleLogger.info("Connected") + _moduleLogger.info("Connected and set up") self.StatusChanged( telepathy.CONNECTION_STATUS_CONNECTED, telepathy.CONNECTION_STATUS_REASON_REQUESTED ) @misc_utils.log_exception(_moduleLogger) + def _on_login_error(self, error): + _moduleLogger.error(error) + if isinstance(error, StopIteration): + pass + elif isinstance(error, gvoice.backend.NetworkError): + self.disconnect(telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR) + else: + self.disconnect(telepathy.CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED) + + @misc_utils.log_exception(_moduleLogger) def Disconnect(self): """ For org.freedesktop.telepathy.Connection @@ -280,7 +315,7 @@ class TheOneRingConnection( def disconnect(self, reason): _moduleLogger.info("Disconnecting") - self._delayedConnect.cancel() + self._timedDisconnect.stop() # Not having the disconnect first can cause weird behavior with clients # including not being able to reconnect or even crashing @@ -296,7 +331,12 @@ class TheOneRingConnection( self.manager.disconnected(self) self.session.save(self.__cachePath) - self.session.logout() + self.session.shutdown() self.session.close() + # In case one of the above items takes too long (which it should never + # do), we leave the starting of the shutdown-on-idle counter to the + # very end + self.manager.disconnect_completed() + _moduleLogger.info("Disconnected")