X-Git-Url: http://git.maemo.org/git/?p=theonering;a=blobdiff_plain;f=src%2Fautogv.py;h=0ebefea13204e0175145a95d53bb9eea91ccd4e7;hp=1955e8b4166f3fc387bf332bc4097642a40367d7;hb=effb4ac5c89ea815abbdd6b4f996d8d539f7407b;hpb=1c892d1b9bf14b28eb54ce3590ed2ee29d5e3d25 diff --git a/src/autogv.py b/src/autogv.py index 1955e8b..0ebefea 100644 --- a/src/autogv.py +++ b/src/autogv.py @@ -1,6 +1,6 @@ import logging -import gobject +import dbus import telepathy try: @@ -20,9 +20,10 @@ import util.coroutines as coroutines import util.go_utils as gobject_utils import util.tp_utils as telepathy_utils import util.misc as misc_utils +import gvoice -_moduleLogger = logging.getLogger("autogv") +_moduleLogger = logging.getLogger(__name__) class NewGVConversations(object): @@ -64,17 +65,18 @@ class NewGVConversations(object): # Just let the TextChannel decide whether it should be reported to the user or not props = self._connRef().generate_props(telepathy.CHANNEL_TYPE_TEXT, h, False) if self._connRef()._channel_manager.channel_exists(props): + _moduleLogger.debug("Chat box already open for texting conversation with %s" % phoneNumber) 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: + newConversations = mergedConv.conversations + newConversations = gvoice.conversations.filter_out_read(newConversations) + newConversations = gvoice.conversations.filter_out_self(newConversations) + newConversations = list(newConversations) + if not newConversations: + _moduleLogger.debug("Not opening chat box for %s, all new messages are either read or from yourself" % phoneNumber) continue chan = self._connRef()._channel_manager.channel_for_props(props, signal=True) @@ -83,10 +85,11 @@ class NewGVConversations(object): class RefreshVoicemail(object): def __init__(self, connRef): + self._isStarted = False self._connRef = connRef + self._newChannelSignaller = telepathy_utils.NewChannelSignaller(self._on_new_channel) self._outstandingRequests = [] - self._isStarted = False def start(self): self._newChannelSignaller.start() @@ -119,7 +122,11 @@ class RefreshVoicemail(object): return conn = telepathy.client.Connection(serviceName, connObjectPath) - chan = telepathy.client.Channel(serviceName, channelObjectPath) + try: + chan = telepathy.client.Channel(serviceName, channelObjectPath) + except dbus.exceptions.UnknownMethodException: + _moduleLogger.exception("Client might not have implemented a deprecated method") + return missDetection = telepathy_utils.WasMissedCall( bus, conn, chan, self._on_missed_call, self._on_error_for_missed ) @@ -137,6 +144,96 @@ class RefreshVoicemail(object): self._outstandingRequests.remove(missDetection) +class AutoAcceptGVCall(object): + + def __init__(self, connRef): + self._connRef = connRef + self._isStarted = False + self._incomingCall = False + self._incomingChannel = False + + self._newChannelSignaller = telepathy_utils.NewChannelSignaller(self._on_new_channel) + + self._bus = dbus.SystemBus() + self._bus.add_signal_receiver( + self._on_incoming, + path='/com/nokia/csd/call', + dbus_interface='com.nokia.csd.Call', + signal_name='Coming' + ) + self._callObject = self._bus.get_object('com.nokia.csd.Call', '/com/nokia/csd/call/1') + self._callInstance = dbus.Interface(self._callObject, 'com.nokia.csd.Call.Instance') + + def start(self): + self._newChannelSignaller.start() + self._isStarted = True + + def stop(self): + if not self._isStarted: + _moduleLogger.info("auto-accept monitor stopped without starting") + return + _moduleLogger.info("Stopping auto-accepting") + self._newChannelSignaller.stop() + + self._incomingCall = False + self._incomingChannel = False + self._isStarted = False + + @misc_utils.log_exception(_moduleLogger) + def _on_new_channel(self, bus, serviceName, connObjectPath, channelObjectPath, channelType): + if channelType != telepathy.interfaces.CHANNEL_TYPE_STREAMED_MEDIA: + return + + cmName = telepathy_utils.cm_from_path(connObjectPath) + if cmName == constants._telepathy_implementation_name_: + _moduleLogger.debug("Ignoring channels from self to prevent deadlock") + return + + conn = telepathy.client.Connection(serviceName, connObjectPath) + try: + chan = telepathy.client.Channel(serviceName, channelObjectPath) + except dbus.exceptions.UnknownMethodException: + _moduleLogger.exception("Client might not have implemented a deprecated method") + return + + chan[telepathy.interfaces.CHANNEL].connect_to_signal( + "Closed", + self._on_closed, + ) + + self._incomingChannel = True + self._accept_if_ready() + + @misc_utils.log_exception(_moduleLogger) + def _on_incoming(self, objPath, callerNumber): + if self._isStarted: + self._incomingCall = True + self._accept_if_ready() + + @misc_utils.log_exception(_moduleLogger) + def _on_closed(self): + self._incomingCall = False + self._incomingChannel = False + + +class TimedDisconnect(object): + + def __init__(self, connRef): + self._connRef = connRef + self.__delayedDisconnect = gobject_utils.Timeout(self._on_delayed_disconnect) + + def start(self): + self.__delayedDisconnect.start(seconds=60) + + def stop(self): + self.__delayedDisconnect.cancel() + + @misc_utils.log_exception(_moduleLogger) + def _on_delayed_disconnect(self): + _moduleLogger.info("Timed disconnect occurred") + self._connRef().disconnect(telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR) + + class AutoDisconnect(object): def __init__(self, connRef): @@ -175,13 +272,14 @@ class AutoDisconnect(object): else: _moduleLogger.info("Other status: %r" % (status, )) + @misc_utils.log_exception(_moduleLogger) def _cancel_delayed_disconnect(self): _moduleLogger.info("Cancelling auto-log off") self.__delayedDisconnect.cancel() @misc_utils.log_exception(_moduleLogger) def _on_delayed_disconnect(self): - if not self.session.is_logged_in(): + if not self._connRef().session.is_logged_in(): _moduleLogger.info("Received connection change event when not logged in") return try: @@ -228,6 +326,28 @@ class DisconnectOnShutdown(object): @note Hildon specific """ try: - self._connRef().disconnect(telepathy.CONNECTION_STATUS_REASON_REQUEST) + self._connRef().disconnect(telepathy.CONNECTION_STATUS_REASON_REQUESTED) except Exception: _moduleLogger.exception("Error durring disconnect") + + +class DelayEnableContactIntegration(object): + + def __init__(self, protocolName): + self.__enableSystemContactSupport = telepathy_utils.EnableSystemContactIntegration( + protocolName + ) + self.__delayedEnable = gobject_utils.Async(self._on_delayed_enable) + + def start(self): + self.__delayedEnable.start() + + def stop(self): + self.__delayedEnable.cancel() + + @misc_utils.log_exception(_moduleLogger) + def _on_delayed_enable(self): + try: + self.__enableSystemContactSupport.start() + except dbus.DBusException, e: + _moduleLogger.info("Contact integration seems to not be supported (%s)" % e)