X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fconnection.py;h=be98d59f1d4ed4605b35e8f028e53cc160c7f7e0;hp=18bdd4e6062b3f615b8c1dd6eb45e5cbfc66cfc8;hb=3ae1df25c091b2bfb6b88b1d4023b868e63ce92f;hpb=e341c7c446d4f85d2a859f0dc6c6e490655ead1a diff --git a/src/connection.py b/src/connection.py index 18bdd4e..be98d59 100644 --- a/src/connection.py +++ b/src/connection.py @@ -1,13 +1,9 @@ """ -@todo Add params for disable/enable state machines -@todo Separate voicemail/sms into separate conversation instances -@todo Setup addressbook, voicemail, sms state machines +@todo Add params for different state machines update times @todo Add option to use screen name as callback @todo Get a callback for missed calls to force an update of the voicemail state machine @todo Get a callback on an incoming call and if its from GV, auto-pickup -@todo Use state-strategies to keep mega-state-machine generic -@todo Observe when connected/disconnected to disconnect CM """ @@ -16,14 +12,21 @@ import logging import telepathy +try: + import conic as _conic + conic = _conic +except (ImportError, OSError): + conic = None + import constants -import util.go_utils as gobject_utils +import tp import util.coroutines as coroutines import gtk_toolbox import gvoice import handle +import requests import contacts import aliasing import simple_presence @@ -37,8 +40,8 @@ _moduleLogger = logging.getLogger("connection") class TheOneRingConnection( - telepathy.server.Connection, - telepathy.server.ConnectionInterfaceRequests, # already a mixin + tp.Connection, + requests.RequestsMixin, contacts.ContactsMixin, aliasing.AliasingMixin, simple_presence.SimplePresenceMixin, @@ -70,53 +73,75 @@ class TheOneRingConnection( raise telepathy.errors.InvalidArgument("User must specify what number GV forwards calls to") # Connection init must come first - telepathy.server.Connection.__init__( + tp.Connection.__init__( self, constants._telepathy_protocol_name_, account, constants._telepathy_implementation_name_ ) - telepathy.server.ConnectionInterfaceRequests.__init__(self) + requests.RequestsMixin.__init__(self) contacts.ContactsMixin.__init__(self) aliasing.AliasingMixin.__init__(self) simple_presence.SimplePresenceMixin.__init__(self) presence.PresenceMixin.__init__(self) capabilities.CapabilitiesMixin.__init__(self) - self._manager = weakref.proxy(manager) - self._credentials = ( + self.__manager = weakref.proxy(manager) + self.__credentials = ( encodedAccount, encodedPassword, ) - self._callbackNumber = encodedCallback - self._channelManager = channel_manager.ChannelManager(self) + self.__callbackNumber = encodedCallback + self.__channelManager = channel_manager.ChannelManager(self) - self._session = gvoice.session.Session(None) + self.__session = gvoice.session.Session(None) + if conic is not None: + self.__connection = conic.Connection() + self.__connectionEventId = None + else: + self.__connection = None + self.__connectionEventId = None self.set_self_handle(handle.create_handle(self, 'connection')) - self._callback = None + self.__callback = None _moduleLogger.info("Connection to the account %s created" % account) @property def manager(self): - return self._manager + return self.__manager @property def session(self): - return self._session + return self.__session @property def username(self): - return self._credentials[0] + return self.__credentials[0] @property def userAliasType(self): return self.USER_ALIAS_ACCOUNT - def handle(self, handleType, handleId): - self.check_handle(handleType, handleId) - return self._handles[handleType, handleId] + def get_handle_by_name(self, handleType, handleName): + requestedHandleName = handleName.encode('utf-8') + if handleType == telepathy.HANDLE_TYPE_CONTACT: + _moduleLogger.info("RequestHandles Contact: %s" % requestedHandleName) + requestedContactId, requestedContactNumber = handle.ContactHandle.from_handle_name( + requestedHandleName + ) + h = handle.create_handle(self, 'contact', requestedContactId, requestedContactNumber) + elif handleType == telepathy.HANDLE_TYPE_LIST: + # Support only server side (immutable) lists + _moduleLogger.info("RequestHandles List: %s" % requestedHandleName) + h = handle.create_handle(self, 'list', requestedHandleName) + else: + raise telepathy.errors.NotAvailable('Handle type unsupported %d' % handleType) + return h + + @property + def _channel_manager(self): + return self.__channelManager @gtk_toolbox.log_exception(_moduleLogger) def Connect(self): @@ -130,61 +155,57 @@ class TheOneRingConnection( ) try: cookieFilePath = None - self._session = gvoice.session.Session(cookieFilePath) + self.__session = gvoice.session.Session(cookieFilePath) - self._callback = coroutines.func_sink( + self.__callback = coroutines.func_sink( coroutines.expand_positional( self._on_conversations_updated ) ) - self.session.conversations.updateSignalHandler.register_sink( - self._callback + self.session.voicemails.updateSignalHandler.register_sink( + self.__callback + ) + self.session.texts.updateSignalHandler.register_sink( + self.__callback ) - self.session.login(*self._credentials) - self.session.backend.set_callback_number(self._callbackNumber) + self.session.login(*self.__credentials) + self.session.backend.set_callback_number(self.__callbackNumber) 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 ) - else: - _moduleLogger.info("Connected") - self.StatusChanged( - telepathy.CONNECTION_STATUS_CONNECTED, - telepathy.CONNECTION_STATUS_REASON_REQUESTED - ) + return + + _moduleLogger.info("Connected") + self.StatusChanged( + telepathy.CONNECTION_STATUS_CONNECTED, + telepathy.CONNECTION_STATUS_REASON_REQUESTED + ) + if self.__connection is not None: + self.__connectionEventId = self.__connection.connect("connection-event", self._on_connection_change) @gtk_toolbox.log_exception(_moduleLogger) def Disconnect(self): """ For org.freedesktop.telepathy.Connection - @bug Not properly logging out. Cookie files need to be per connection and removed """ - _moduleLogger.info("Disconnecting") - try: - self.session.conversations.updateSignalHandler.unregister_sink( - self._callback - ) - self._callback = None - self._channelManager.close() - self.session.logout() - self.session.close() - self._session = None - _moduleLogger.info("Disconnected") - except Exception: - _moduleLogger.exception("Disconnecting Failed") self.StatusChanged( telepathy.CONNECTION_STATUS_DISCONNECTED, telepathy.CONNECTION_STATUS_REASON_REQUESTED ) - self.manager.disconnected(self) + try: + self._disconnect() + except Exception: + _moduleLogger.exception("Error durring disconnect") @gtk_toolbox.log_exception(_moduleLogger) def RequestChannel(self, type, handleType, handleId, suppressHandler): @@ -199,45 +220,15 @@ class TheOneRingConnection( self.check_connected() self.check_handle(handleType, handleId) - h = self.handle(handleType, handleId) if handleId != 0 else None + h = self.get_handle_by_id(handleType, handleId) if handleId != 0 else None props = self._generate_props(type, h, suppressHandler) - if hasattr(self, "_validate_handle"): - # HACK Newer python-telepathy - self._validate_handle(props) + self._validate_handle(props) - chan = self._channelManager.channel_for_props(props, signal=True) + chan = self.__channelManager.channel_for_props(props, signal=True) path = chan._object_path _moduleLogger.info("RequestChannel Object Path: %s" % path) return path - @gtk_toolbox.log_exception(_moduleLogger) - def RequestHandles(self, handleType, names, sender): - """ - For org.freedesktop.telepathy.Connection - Overiding telepathy.server.Connecton to allow custom handles - """ - self.check_connected() - self.check_handle_type(handleType) - - handles = [] - for name in names: - requestedHandleName = name.encode('utf-8') - if handleType == telepathy.HANDLE_TYPE_CONTACT: - _moduleLogger.info("RequestHandles Contact: %s" % requestedHandleName) - requestedContactId, requestedContactNumber = handle.ContactHandle.from_handle_name( - requestedHandleName - ) - h = handle.create_handle(self, 'contact', requestedContactId, requestedContactNumber) - elif handleType == telepathy.HANDLE_TYPE_LIST: - # Support only server side (immutable) lists - _moduleLogger.info("RequestHandles List: %s" % requestedHandleName) - h = handle.create_handle(self, 'list', requestedHandleName) - else: - raise telepathy.errors.NotAvailable('Handle type unsupported %d' % handleType) - handles.append(h.id) - self.add_client_handle(h, sender) - return handles - 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() @@ -253,14 +244,53 @@ class TheOneRingConnection( return props - @gobject_utils.async + def _disconnect(self): + _moduleLogger.info("Disconnecting") + self.session.voicemails.updateSignalHandler.unregister_sink( + self.__callback + ) + self.session.texts.updateSignalHandler.unregister_sink( + self.__callback + ) + self.__callback = None + + self.__channelManager.close() + self.session.logout() + self.session.close() + self.__session = None + if self.__connection is not None: + self.__connection.disconnect(self.__connectionEventId) + self.__connectionEventId = None + + self.manager.disconnected(self) + _moduleLogger.info("Disconnected") + @gtk_toolbox.log_exception(_moduleLogger) def _on_conversations_updated(self, conv, conversationIds): - # @todo get conversations update running - # @todo test conversatiuons - _moduleLogger.info("Incoming messages from: %r" % (conversationIds, )) + _moduleLogger.debug("Incoming messages from: %r" % (conversationIds, )) for contactId, phoneNumber in conversationIds: h = handle.create_handle(self, 'contact', contactId, phoneNumber) # Just let the TextChannel decide whether it should be reported to the user or not props = self._generate_props(telepathy.CHANNEL_TYPE_TEXT, h, False) - channel = self._channelManager.channel_for_props(props, signal=True) + channel = self.__channelManager.channel_for_props(props, signal=True) + + @gtk_toolbox.log_exception(_moduleLogger) + def _on_connection_change(self, connection, event): + """ + @note Maemo specific + """ + status = event.get_status() + error = event.get_error() + iap_id = event.get_iap_id() + bearer = event.get_bearer_type() + + if status == conic.STATUS_DISCONNECTED: + _moduleLogger.info("Disconnecting due to loss of network connection") + self.StatusChanged( + telepathy.CONNECTION_STATUS_DISCONNECTED, + telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR + ) + try: + self._disconnect() + except Exception: + _moduleLogger.exception("Error durring disconnect")