X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fconnection.py;h=22d688569d2ef0046103dab4d1e8607aae6772e5;hp=e7d1da619a2c6f1b7718a3d0761ac6579d9a6649;hb=f8ffc8e5741b1dc7f7ac43ca80a66191b8c881b1;hpb=243f514ed4cc40f72d148f8795413c7a527fc7d2 diff --git a/src/connection.py b/src/connection.py index e7d1da6..22d6885 100644 --- a/src/connection.py +++ b/src/connection.py @@ -1,66 +1,86 @@ - -""" -@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 Observe when connected/disconnected to disconnect CM -""" - - +import os import weakref 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 util.coroutines as coroutines +import tp +import util.misc as util_misc import gtk_toolbox import gvoice import handle +import requests import contacts import aliasing import simple_presence import presence import capabilities +import autogv import channel_manager _moduleLogger = logging.getLogger("connection") +class TheOneRingOptions(object): + + useGVContacts = True + + assert gvoice.session.Session._DEFAULTS["contacts"][1] == "hours" + contactsPollPeriodInHours = gvoice.session.Session._DEFAULTS["contacts"][0] + + assert gvoice.session.Session._DEFAULTS["voicemail"][1] == "minutes" + voicemailPollPeriodInMinutes = gvoice.session.Session._DEFAULTS["voicemail"][0] + + assert gvoice.session.Session._DEFAULTS["texts"][1] == "minutes" + textsPollPeriodInMinutes = gvoice.session.Session._DEFAULTS["texts"][0] + + def __init__(self, parameters = None): + if parameters is None: + return + self.useGVContacts = parameters["use-gv-contacts"] + self.contactsPollPeriodInHours = parameters['contacts-poll-period-in-hours'] + self.voicemailPollPeriodInMinutes = parameters['voicemail-poll-period-in-minutes'] + self.textsPollPeriodInMinutes = parameters['texts-poll-period-in-minutes'] + + class TheOneRingConnection( - telepathy.server.Connection, - telepathy.server.ConnectionInterfaceRequests, # already a mixin - #contacts.ContactsMixin, + tp.Connection, + requests.RequestsMixin, + contacts.ContactsMixin, 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? + # overiding base class variable _mandatory_parameters = { - 'account' : 's', - 'password' : 's', - 'forward' : 's', + 'account': 's', + 'password': 's', } - # Overriding a base class variable + # overiding base class variable _optional_parameters = { + 'forward': 's', + 'use-gv-contacts': 'b', + 'contacts-poll-period-in-hours': 'i', + 'voicemail-poll-period-in-minutes': 'i', + 'texts-poll-period-in-minutes': 'i', } _parameter_defaults = { + 'forward': '', + 'use-gv-contacts': TheOneRingOptions.useGVContacts, + 'contacts-poll-period-in-hours': TheOneRingOptions.contactsPollPeriodInHours, + 'voicemail-poll-period-in-minutes': TheOneRingOptions.voicemailPollPeriodInMinutes, + 'texts-poll-period-in-minutes': TheOneRingOptions.textsPollPeriodInMinutes, } + _secret_parameters = set(( + "password", + )) @gtk_toolbox.log_exception(_moduleLogger) def __init__(self, manager, parameters): @@ -68,64 +88,93 @@ class TheOneRingConnection( 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") + encodedCallback = util_misc.normalize_number(parameters['forward'].encode('utf-8')) + if encodedCallback and not util_misc.is_valid_number(encodedCallback): + raise telepathy.errors.InvalidArgument("Invalid forwarding number") # Connection init must come first - telepathy.server.Connection.__init__( + self.__options = TheOneRingOptions(parameters) + self.__session = gvoice.session.Session( + cookiePath = None, + defaults = { + "contacts": (self.__options.contactsPollPeriodInHours, "hours"), + "voicemail": (self.__options.voicemailPollPeriodInMinutes, "minutes"), + "texts": (self.__options.textsPollPeriodInMinutes, "minutes"), + }, + ) + tp.Connection.__init__( self, constants._telepathy_protocol_name_, account, constants._telepathy_implementation_name_ ) - telepathy.server.ConnectionInterfaceRequests.__init__(self) - #contacts.ContactsMixin.__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.__callbackNumberParameter = encodedCallback + self.__channelManager = channel_manager.ChannelManager(self) - 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.__cachePath = os.sep.join((constants._data_path_, "cache", self.username)) + try: + os.makedirs(self.__cachePath) + except OSError, e: + if e.errno != 17: + raise self.set_self_handle(handle.create_handle(self, 'connection')) + self._plumbing = [ + autogv.NewGVConversations(weakref.ref(self)), + autogv.RefreshVoicemail(weakref.ref(self)), + autogv.AutoDisconnect(weakref.ref(self)), + ] - 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 options(self): + return self.__options @property def username(self): - return self._credentials[0] + return self.__credentials[0] @property - def userAliasType(self): - return self.USER_ALIAS_ACCOUNT + def callbackNumberParameter(self): + return self.__callbackNumberParameter + + def get_handle_by_name(self, handleType, handleName): + requestedHandleName = handleName.encode('utf-8') + 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) + return h - def handle(self, handleType, handleId): - self.check_handle(handleType, handleId) - return self._handles[handleType, handleId] + @property + def _channel_manager(self): + return self.__channelManager @gtk_toolbox.log_exception(_moduleLogger) def Connect(self): @@ -138,22 +187,24 @@ 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.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.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.__callbackNumberParameter = util_misc.normalize_number(callback) + self.session.backend.set_callback_number(self.__callbackNumberParameter) + + subscribeHandle = self.get_handle_by_name(telepathy.HANDLE_TYPE_LIST, "subscribe") + subscribeProps = self.generate_props(telepathy.CHANNEL_TYPE_CONTACT_LIST, subscribeHandle, False) + self.__channelManager.channel_for_props(subscribeProps, signal=True) + 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( @@ -174,21 +225,14 @@ class TheOneRingConnection( 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 """ - self.StatusChanged( - telepathy.CONNECTION_STATUS_DISCONNECTED, - telepathy.CONNECTION_STATUS_REASON_REQUESTED - ) try: - self._disconnect() + self.disconnect(telepathy.CONNECTION_STATUS_REASON_REQUESTED) except Exception: _moduleLogger.exception("Error durring disconnect") @@ -205,46 +249,16 @@ class TheOneRingConnection( self.check_connected() self.check_handle(handleType, handleId) - 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) + h = self.get_handle_by_id(handleType, handleId) if handleId != 0 else None + props = self.generate_props(type, h, suppressHandler) + 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) + _moduleLogger.info("RequestChannel Object Path (%s): %s" % (type.rsplit(".", 1)[-1], 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): + 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 = { @@ -259,54 +273,22 @@ class TheOneRingConnection( return props - def _disconnect(self): + def disconnect(self, reason): _moduleLogger.info("Disconnecting") - self.session.voicemails.updateSignalHandler.unregister_sink( - self._callback - ) - self.session.texts.updateSignalHandler.unregister_sink( - self._callback + # 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, ) - self._callback = None - self._channelManager.close() + for plumber in self._plumbing: + plumber.stop() + + self.__channelManager.close() + self.session.save(self.__cachePath) 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") - - @gobject_utils.async - @gtk_toolbox.log_exception(_moduleLogger) - def _on_conversations_updated(self, conv, 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) - - @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")