X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fconnection.py;h=22f09053d32f954d605afc62be4cff7d29e1dde1;hb=7c771815562d443e4ba262a195267f844cd4f99e;hp=eb2abc6a33294e90ae06333e108beb101ecb4941;hpb=59327fe23f05616d0976777d00ae0024f2ea0265;p=theonering diff --git a/src/connection.py b/src/connection.py index eb2abc6..22f0905 100644 --- a/src/connection.py +++ b/src/connection.py @@ -1,13 +1,27 @@ + +""" +@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 option to use screen name as callback +""" + + import weakref import logging import telepathy import constants +import util.go_utils as gobject_utils +import util.coroutines as coroutines import gtk_toolbox import gvoice import handle import aliasing +import simple_presence +import presence +import capabilities import channel_manager @@ -16,12 +30,16 @@ _moduleLogger = logging.getLogger("connection") class TheOneRingConnection( telepathy.server.Connection, - aliasing.AliasingMixin + aliasing.AliasingMixin, + simple_presence.SimplePresenceMixin, + presence.PresenceMixin, + capabilities.CapabilitiesMixin, ): # Overriding a base class variable + # Should the forwarding number be handled by the alias or by an option? _mandatory_parameters = { - 'username' : 's', + 'account' : 's', 'password' : 's', 'forward' : 's', } @@ -31,37 +49,42 @@ class TheOneRingConnection( _parameter_defaults = { } + @gtk_toolbox.log_exception(_moduleLogger) def __init__(self, manager, parameters): - try: - self.check_parameters(parameters) - account = unicode(parameters['username']) - - # Connection init must come first - telepathy.server.Connection.__init__( - self, - constants._telepathy_protocol_name_, - account, - constants._telepathy_implementation_name_ - ) - aliasing.AliasingMixin.__init__(self) - - self._manager = weakref.proxy(manager) - self._credentials = ( - parameters['username'].encode('utf-8'), - parameters['password'].encode('utf-8'), - ) - self._callbackNumber = parameters['forward'].encode('utf-8') - self._channelManager = channel_manager.ChannelManager(self) + self.check_parameters(parameters) + account = unicode(parameters['account']) + encodedAccount = parameters['account'].encode('utf-8') + encodedPassword = parameters['password'].encode('utf-8') + encodedCallback = parameters['forward'].encode('utf-8') + if not encodedCallback: + raise telepathy.errors.InvalidArgument("User must specify what number GV forwards calls to") + + # Connection init must come first + telepathy.server.Connection.__init__( + self, + constants._telepathy_protocol_name_, + account, + constants._telepathy_implementation_name_ + ) + aliasing.AliasingMixin.__init__(self) + simple_presence.SimplePresenceMixin.__init__(self) + presence.PresenceMixin.__init__(self) + capabilities.CapabilitiesMixin.__init__(self) + + self._manager = weakref.proxy(manager) + self._credentials = ( + encodedAccount, + encodedPassword, + ) + self._callbackNumber = encodedCallback + self._channelManager = channel_manager.ChannelManager(self) - cookieFilePath = "%s/cookies.txt" % constants._data_path_ - self._session = gvoice.session.Session(cookieFilePath) + self._session = gvoice.session.Session(None) - self.set_self_handle(handle.create_handle(self, 'connection')) + self.set_self_handle(handle.create_handle(self, 'connection')) - _moduleLogger.info("Connection to the account %s created" % account) - except Exception, e: - _moduleLogger.exception("Failed to create Connection") - raise + self._callback = None + _moduleLogger.info("Connection to the account %s created" % account) @property def manager(self): @@ -75,6 +98,10 @@ class TheOneRingConnection( def username(self): 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] @@ -90,6 +117,17 @@ class TheOneRingConnection( telepathy.CONNECTION_STATUS_REASON_REQUESTED ) try: + cookieFilePath = None + self._session = gvoice.session.Session(cookieFilePath) + + self._callback = coroutines.func_sink( + coroutines.expand_positional( + self._on_conversations_updated + ) + ) + self.session.conversations.updateSignalHandler.register_sink( + self._callback + ) self.session.login(*self._credentials) self.session.backend.set_callback_number(self._callbackNumber) except gvoice.backend.NetworkError, e: @@ -119,7 +157,14 @@ class TheOneRingConnection( """ _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") @@ -127,6 +172,7 @@ class TheOneRingConnection( telepathy.CONNECTION_STATUS_DISCONNECTED, telepathy.CONNECTION_STATUS_REASON_REQUESTED ) + self.manager.disconnected(self) @gtk_toolbox.log_exception(_moduleLogger) def RequestChannel(self, type, handleType, handleId, suppressHandler): @@ -141,24 +187,16 @@ class TheOneRingConnection( self.check_connected() self.check_handle(handleType, handleId) - channel = None - channelManager = self._channelManager - handle = self.handle(handleType, handleId) - - if type == telepathy.CHANNEL_TYPE_CONTACT_LIST: - _moduleLogger.info("RequestChannel ContactList") - channel = channelManager.channel_for_list(handle, suppressHandler) - elif type == telepathy.CHANNEL_TYPE_TEXT: - _moduleLogger.info("RequestChannel Text") - channel = channelManager.channel_for_text(handle, suppressHandler) - elif type == telepathy.CHANNEL_TYPE_STREAMED_MEDIA: - _moduleLogger.info("RequestChannel Media") - channel = channelManager.channel_for_call(handle, suppressHandler) - else: - raise telepathy.NotImplemented("unknown channel type %s" % type) + h = self.handle(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) - _moduleLogger.info("RequestChannel Object Path: %s" % channel._object_path) - return channel._object_path + 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): @@ -171,35 +209,46 @@ class TheOneRingConnection( handles = [] for name in names: - name = name.encode('utf-8') + requestedHandleName = name.encode('utf-8') if handleType == telepathy.HANDLE_TYPE_CONTACT: - _moduleLogger.info("RequestHandles Contact: %s" % name) - h = self._create_contact_handle(name) + _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" % name) - h = handle.create_handle(self, 'list', name) + _moduleLogger.info("RequestHandles List: %s" % requestedHandleName) + h = handle.create_handle(self, 'list', requestedHandleName) else: - raise telepathy.NotAvailable('Handle type unsupported %d' % handleType) + raise telepathy.errors.NotAvailable('Handle type unsupported %d' % handleType) handles.append(h.id) self.add_client_handle(h, sender) return handles - def _create_contact_handle(self, requestedHandleName): - """ - @todo Determine if nay of this is really needed - """ - requestedContactId, requestedContactNumber = handle.ContactHandle.from_handle_name( - requestedHandleName - ) - h = handle.create_handle(self, 'contact', requestedContactId, requestedContactNumber) - return h + 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() + props = { + telepathy.CHANNEL_INTERFACE + '.ChannelType': channelType, + telepathy.CHANNEL_INTERFACE + '.TargetHandle': targetHandle, + telepathy.CHANNEL_INTERFACE + '.TargetHandleType': targetHandleType, + telepathy.CHANNEL_INTERFACE + '.Requested': suppressHandler + } - def _on_invite_text(self, contactId): - """ - @todo Make this work - """ - h = self._create_contact_handle(contactId) + if initiatorHandle is not None: + props[telepathy.CHANNEL_INTERFACE + '.InitiatorHandle'] = initiatorHandle.id + + return props - channelManager = self._channelManager - channel = channelManager.channel_for_text(handle) + @gobject_utils.async + @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, )) + 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)