X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fconnection.py;h=59ffa76932a8e89e0ea8874ab5ec9466727f517a;hp=41ea91200fba605ed43204fda6152cebe977243e;hb=013fc091b26c448800719a13ecd1f18d9eb8b7d2;hpb=b53d4046e4ca322bd00e768e171c34f38bbe3d7a diff --git a/src/connection.py b/src/connection.py index 41ea912..59ffa76 100644 --- a/src/connection.py +++ b/src/connection.py @@ -6,24 +6,24 @@ import telepathy import constants import tp -import util.misc as util_misc -import gtk_toolbox +import util.misc as misc_utils import gvoice import handle -import requests -import contacts import aliasing -import simple_presence -import presence +import avatars import capabilities +import contacts +import presence +import requests +import simple_presence import autogv import channel_manager -_moduleLogger = logging.getLogger("connection") +_moduleLogger = logging.getLogger(__name__) class TheOneRingOptions(object): @@ -50,12 +50,13 @@ class TheOneRingOptions(object): class TheOneRingConnection( tp.Connection, - requests.RequestsMixin, - contacts.ContactsMixin, aliasing.AliasingMixin, - simple_presence.SimplePresenceMixin, - presence.PresenceMixin, + avatars.AvatarsMixin, capabilities.CapabilitiesMixin, + contacts.ContactsMixin, + presence.PresenceMixin, + requests.RequestsMixin, + simple_presence.SimplePresenceMixin, ): # overiding base class variable @@ -82,14 +83,14 @@ class TheOneRingConnection( "password", )) - @gtk_toolbox.log_exception(_moduleLogger) + @misc_utils.log_exception(_moduleLogger) def __init__(self, manager, parameters): self.check_parameters(parameters) account = unicode(parameters['account']) encodedAccount = parameters['account'].encode('utf-8') encodedPassword = parameters['password'].encode('utf-8') - encodedCallback = util_misc.normalize_number(parameters['forward'].encode('utf-8')) - if encodedCallback and not util_misc.is_valid_number(encodedCallback): + encodedCallback = misc_utils.normalize_number(parameters['forward'].encode('utf-8')) + if encodedCallback and not misc_utils.is_valid_number(encodedCallback): raise telepathy.errors.InvalidArgument("Invalid forwarding number") # Connection init must come first @@ -108,12 +109,13 @@ class TheOneRingConnection( account, constants._telepathy_implementation_name_ ) - requests.RequestsMixin.__init__(self) - contacts.ContactsMixin.__init__(self) aliasing.AliasingMixin.__init__(self) - simple_presence.SimplePresenceMixin.__init__(self) - presence.PresenceMixin.__init__(self) + avatars.AvatarsMixin.__init__(self) capabilities.CapabilitiesMixin.__init__(self) + contacts.ContactsMixin.__init__(self) + presence.PresenceMixin.__init__(self) + requests.RequestsMixin.__init__(self) + simple_presence.SimplePresenceMixin.__init__(self) self.__manager = weakref.proxy(manager) self.__credentials = ( @@ -135,9 +137,12 @@ class TheOneRingConnection( autogv.NewGVConversations(weakref.ref(self)), autogv.RefreshVoicemail(weakref.ref(self)), autogv.AutoDisconnect(weakref.ref(self)), + autogv.DelayEnableContactIntegration(constants._telepathy_implementation_name_), ] _moduleLogger.info("Connection to the account %s created" % account) + self._timedDisconnect = autogv.TimedDisconnect(weakref.ref(self)) + self._timedDisconnect.start() @property def manager(self): @@ -161,42 +166,66 @@ 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 @property def _channel_manager(self): return self.__channelManager - @gtk_toolbox.log_exception(_moduleLogger) + @misc_utils.log_exception(_moduleLogger) def Connect(self): """ For org.freedesktop.telepathy.Connection """ + if self._status != telepathy.CONNECTION_STATUS_DISCONNECTED: + _moduleLogger.info("Attempting connect when not disconnected") + return _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 ) - self.__callbackNumberParameter = util_misc.normalize_number(callback) + self.__callbackNumberParameter = misc_utils.normalize_number(callback) self.session.backend.set_callback_number(self.__callbackNumberParameter) subscribeHandle = self.get_handle_by_name(telepathy.HANDLE_TYPE_LIST, "subscribe") @@ -205,42 +234,36 @@ 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, e: - _moduleLogger.exception("Connection Failed") - self.StatusChanged( - telepathy.CONNECTION_STATUS_DISCONNECTED, - telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR - ) - return - except Exception, e: - _moduleLogger.exception("Connection Failed") - self.StatusChanged( - telepathy.CONNECTION_STATUS_DISCONNECTED, - telepathy.CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED - ) + except Exception: + _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 ) - @gtk_toolbox.log_exception(_moduleLogger) + @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 """ - try: - self.disconnect() - except Exception: - _moduleLogger.exception("Error durring disconnect") - self.StatusChanged( - telepathy.CONNECTION_STATUS_DISCONNECTED, - telepathy.CONNECTION_STATUS_REASON_REQUESTED - ) + _moduleLogger.info("Kicking off disconnect") + self.disconnect(telepathy.CONNECTION_STATUS_REASON_REQUESTED) - @gtk_toolbox.log_exception(_moduleLogger) + @misc_utils.log_exception(_moduleLogger) def RequestChannel(self, type, handleType, handleId, suppressHandler): """ For org.freedesktop.telepathy.Connection @@ -262,9 +285,9 @@ class TheOneRingConnection( _moduleLogger.info("RequestChannel Object Path (%s): %s" % (type.rsplit(".", 1)[-1], path)) return path - def generate_props(self, channelType, handle, suppressHandler, initiatorHandle=None): - targetHandle = 0 if handle is None else handle.get_id() - targetHandleType = telepathy.HANDLE_TYPE_NONE if handle is None else handle.get_type() + def generate_props(self, channelType, handleObj, suppressHandler, initiatorHandle=None): + targetHandle = 0 if handleObj is None else handleObj.get_id() + targetHandleType = telepathy.HANDLE_TYPE_NONE if handleObj is None else handleObj.get_type() props = { telepathy.CHANNEL_INTERFACE + '.ChannelType': channelType, telepathy.CHANNEL_INTERFACE + '.TargetHandle': targetHandle, @@ -277,15 +300,31 @@ class TheOneRingConnection( return props - def disconnect(self): + def disconnect(self, reason): _moduleLogger.info("Disconnecting") + + self._timedDisconnect.stop() + + # Not having the disconnect first can cause weird behavior with clients + # including not being able to reconnect or even crashing + self.StatusChanged( + telepathy.CONNECTION_STATUS_DISCONNECTED, + reason, + ) + for plumber in self._plumbing: plumber.stop() self.__channelManager.close() + self.manager.disconnected(self) + self.session.save(self.__cachePath) self.session.logout() self.session.close() - self.manager.disconnected(self) + # 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")