Breaking the contant out to a variable

[theonering] / src / channel / text.py

diff --git a/src/channel/text.py b/src/channel/text.py
index c7a7da5..bd54a81 100644 (file)
--- a/src/channel/text.py
+++ b/src/channel/text.py
@@ -1,28 +1,26 @@
 import time
-import datetime
 import logging
 
 import telepathy
 
 import tp
 import util.coroutines as coroutines
-import gtk_toolbox
+import util.misc as misc_utils
+import gvoice
 
 
-_moduleLogger = logging.getLogger("channel.text")
+_moduleLogger = logging.getLogger(__name__)
 
 
 class TextChannel(tp.ChannelTypeText):
 
-       NULL_TIMESTAMP = datetime.datetime(1, 1, 1)
-
        def __init__(self, connection, manager, props, contactHandle):
                self.__manager = manager
                self.__props = props
 
                tp.ChannelTypeText.__init__(self, connection, manager, props)
                self.__nextRecievedId = 0
-               self.__lastMessageTimestamp = self.NULL_TIMESTAMP
+               self.__hasServerBeenPolled = False
 
                self.__otherHandle = contactHandle
 
@@ -38,6 +36,8 @@ class TextChannel(tp.ChannelTypeText):
                        self.__callback
                )
 
+               self._filter_out_reported = gvoice.conversations.FilterOutReported()
+
                # The only reason there should be anything in the conversation is if
                # its new, so report it all
                try:
@@ -53,12 +53,12 @@ class TextChannel(tp.ChannelTypeText):
                else:
                        self._report_conversation(mergedConversations)
 
-       @gtk_toolbox.log_exception(_moduleLogger)
+       @misc_utils.log_exception(_moduleLogger)
        def Send(self, messageType, text):
                if messageType != telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL:
                        raise telepathy.errors.NotImplemented("Unhandled message type: %r" % messageType)
 
-               if self.__lastMessageTimestamp == self.NULL_TIMESTAMP:
+               if not self.__hasServerBeenPolled:
                        # Hack: GV marks messages as read when they are replied to.  If GV
                        # marks them as read than we ignore them.  So reduce the window for
                        # them being marked as read.  Oh and Conversations already handles
@@ -74,12 +74,12 @@ class TextChannel(tp.ChannelTypeText):
                                )
 
                _moduleLogger.info("Sending message to %r" % (self.__otherHandle, ))
-               self._conn.session.backend.send_sms(self.__otherHandle.phoneNumber, text)
+               self._conn.session.backend.send_sms([self.__otherHandle.phoneNumber], text)
                self._conn.session.textsStateMachine.reset_timers()
 
                self.Sent(int(time.time()), messageType, text)
 
-       @gtk_toolbox.log_exception(_moduleLogger)
+       @misc_utils.log_exception(_moduleLogger)
        def Close(self):
                self.close()
 
@@ -101,7 +101,7 @@ class TextChannel(tp.ChannelTypeText):
                contactKey = self.__otherHandle.phoneNumber
                return contactKey
 
-       @gtk_toolbox.log_exception(_moduleLogger)
+       @misc_utils.log_exception(_moduleLogger)
        def _on_conversations_updated(self, conv, conversationIds):
                if self._contactKey not in conversationIds:
                        return
@@ -110,57 +110,44 @@ class TextChannel(tp.ChannelTypeText):
                self._report_conversation(mergedConversations)
 
        def _report_conversation(self, mergedConversations):
-               # Can't filter out messages in a texting conversation that came in
-               # before the last one sent because that creates a race condition of two
-               # people sending at about the same time, which happens quite a bit
                newConversations = mergedConversations.conversations
                if not newConversations:
-                       _moduleLogger.debug(
+                       _moduleLogger.info(
                                "No messages ended up existing for %r" % (self._contactKey, )
                        )
                        return
+
+               # Can't filter out messages in a texting conversation that came in
+               # before the last one sent because that creates a race condition of two
+               # people sending at about the same time, which happens quite a bit
                newConversations = self._filter_out_reported(newConversations)
-               newConversations = self._filter_out_read(newConversations)
+               newConversations = gvoice.conversations.filter_out_read(newConversations)
+               newConversations = gvoice.conversations.filter_out_self(newConversations)
                newConversations = list(newConversations)
                if not newConversations:
                        _moduleLogger.debug(
                                "New messages for %r have already been read externally" % (self._contactKey, )
                        )
                        return
-               self.__lastMessageTimestamp = newConversations[-1].time
 
                messages = [
                        newMessage
                        for newConversation in newConversations
                        for newMessage in newConversation.messages
-                       if newMessage.whoFrom != "Me:"
+                       if not gvoice.conversations.is_message_from_self(newMessage)
                ]
-               if not newConversations:
+               if not messages:
                        _moduleLogger.debug(
-                               "All incoming messages were really outbound messages for %r" % (self._contactKey, )
+                               "How did this happen for %r?" % (self._contactKey, )
                        )
                        return
-
                for newMessage in messages:
                        formattedMessage = self._format_message(newMessage)
                        self._report_new_message(formattedMessage)
+
                for conv in newConversations:
                        conv.isRead = True
-
-       def _filter_out_reported(self, conversations):
-               return (
-                       conversation
-                       for conversation in conversations
-                       if self.__lastMessageTimestamp < conversation.time
-               )
-
-       @staticmethod
-       def _filter_out_read(conversations):
-               return (
-                       conversation
-                       for conversation in conversations
-                       if not conversation.isRead and not conversation.isArchived
-               )
+               self.__hasServerBeenPolled = True
 
        def _format_message(self, message):
                return " ".join(part.text.strip() for part in message.body)