X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fconnection.py;h=d3951bcd27cd5704e3f5e1b57030c97f83e295af;hp=be98d59f1d4ed4605b35e8f028e53cc160c7f7e0;hb=b58a60f57eb97bfc4fb3008b3edb4618d60ad045;hpb=3ae1df25c091b2bfb6b88b1d4023b868e63ce92f diff --git a/src/connection.py b/src/connection.py index be98d59..d3951bc 100644 --- a/src/connection.py +++ b/src/connection.py @@ -1,15 +1,8 @@ - -""" -@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 -""" - - +import os import weakref import logging +import gobject import telepathy try: @@ -21,6 +14,8 @@ except (ImportError, OSError): import constants import tp import util.coroutines as coroutines +import util.go_utils as gobject_utils +import util.misc as util_misc import gtk_toolbox import gvoice @@ -39,6 +34,28 @@ 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( tp.Connection, requests.RequestsMixin, @@ -49,18 +66,29 @@ class TheOneRingConnection( 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,11 +96,20 @@ 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 + 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_, @@ -91,20 +128,25 @@ class TheOneRingConnection( encodedAccount, encodedPassword, ) - self.__callbackNumber = encodedCallback + 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.__callback = None + self.__connectionEventId = None + self.__delayedDisconnectEventId = None _moduleLogger.info("Connection to the account %s created" % account) @property @@ -116,24 +158,25 @@ class TheOneRingConnection( return self.__session @property + def options(self): + return self.__options + + @property def username(self): 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.info("RequestHandles Contact: %s" % requestedHandleName) - requestedContactId, requestedContactNumber = handle.ContactHandle.from_handle_name( - requestedHandleName - ) - h = handle.create_handle(self, 'contact', requestedContactId, requestedContactNumber) + _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.info("RequestHandles List: %s" % requestedHandleName) + _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) @@ -154,8 +197,7 @@ class TheOneRingConnection( telepathy.CONNECTION_STATUS_REASON_REQUESTED ) try: - cookieFilePath = None - self.__session = gvoice.session.Session(cookieFilePath) + self.__session.load(self.__cachePath) self.__callback = coroutines.func_sink( coroutines.expand_positional( @@ -169,7 +211,19 @@ class TheOneRingConnection( self.__callback ) self.session.login(*self.__credentials) - self.session.backend.set_callback_number(self.__callbackNumber) + if not self.__callbackNumberParameter: + callback = gvoice.backend.get_sane_callback( + self.session.backend + ) + 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( @@ -198,14 +252,14 @@ class TheOneRingConnection( """ For org.freedesktop.telepathy.Connection """ - self.StatusChanged( - telepathy.CONNECTION_STATUS_DISCONNECTED, - telepathy.CONNECTION_STATUS_REASON_REQUESTED - ) try: self._disconnect() except Exception: _moduleLogger.exception("Error durring disconnect") + self.StatusChanged( + telepathy.CONNECTION_STATUS_DISCONNECTED, + telepathy.CONNECTION_STATUS_REASON_REQUESTED + ) @gtk_toolbox.log_exception(_moduleLogger) def RequestChannel(self, type, handleType, handleId, suppressHandler): @@ -226,7 +280,7 @@ class TheOneRingConnection( 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 def _generate_props(self, channelType, handle, suppressHandler, initiatorHandle=None): @@ -255,24 +309,38 @@ class TheOneRingConnection( self.__callback = None 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) + + self._cancel_delayed_disconnect() + self.__connection = None _moduleLogger.info("Disconnected") @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) + for phoneNumber in conversationIds: + h = self.get_handle_by_name(telepathy.HANDLE_TYPE_CONTACT, 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) + if self.__channelManager.channel_exists(props): + continue + + # Maemo 4.1's RTComm opens a window for a chat regardless if a + # message is received or not, so we need to do some filtering here + mergedConv = conv.get_conversation(phoneNumber) + unreadConvs = [ + conversation + for conversation in mergedConv.conversations + if not conversation.isRead and not conversation.isArchived + ] + if not unreadConvs: + continue + + chan = self.__channelManager.channel_for_props(props, signal=True) @gtk_toolbox.log_exception(_moduleLogger) def _on_connection_change(self, connection, event): @@ -285,12 +353,35 @@ class TheOneRingConnection( 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 + _moduleLogger.info("Disconnected from network, starting countdown to logoff") + self.__delayedDisconnectEventId = gobject_utils.timeout_add_seconds( + 5, self._on_delayed_disconnect ) - try: - self._disconnect() - except Exception: - _moduleLogger.exception("Error durring disconnect") + elif status == conic.STATUS_CONNECTED: + _moduleLogger.info("Connected to network") + self._cancel_delayed_disconnect() + else: + _moduleLogger.info("Other status: %r" % (status, )) + + def _cancel_delayed_disconnect(self): + if self.__delayedDisconnectEventId is None: + return + _moduleLogger.info("Cancelling auto-log off") + gobject.source_reove(self.__delayedDisconnectEventId) + self.__delayedDisconnectEventId = None + + @gtk_toolbox.log_exception(_moduleLogger) + def _on_delayed_disconnect(self): + if not self.session.is_logged_in(): + _moduleLogger.info("Received connection change event when not logged in") + return + try: + self._disconnect() + except Exception: + _moduleLogger.exception("Error durring disconnect") + self.StatusChanged( + telepathy.CONNECTION_STATUS_DISCONNECTED, + telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR + ) + self.__delayedDisconnectEventId = None + return False