X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fchannel%2Ftext.py;h=d2c53138dc2d90e9c432c4a49f6a6235162e6c41;hb=7b8b1390728940678226c5587ee9918f1dad58cb;hp=b9f6fe56e75081cd7cb4764ef6cbb25066d0a92c;hpb=bc433598796afa36b5d75b7c40af19abdb573f67;p=theonering

diff --git a/src/channel/text.py b/src/channel/text.py
index b9f6fe5..d2c5313 100644
--- a/src/channel/text.py
+++ b/src/channel/text.py
@@ -17,25 +17,38 @@ class TextChannel(telepathy.server.ChannelTypeText):
 	Look into implementing ChannelInterfaceMessages for rich text formatting
 	"""
 
-	def __init__(self, connection, h):
-		telepathy.server.ChannelTypeText.__init__(self, connection, h)
+	def __init__(self, connection, manager, props, contactHandle):
+		self._manager = manager
+		self._props = props
+
+		try:
+			# HACK Older python-telepathy way
+			telepathy.server.ChannelTypeText.__init__(self, connection, contactHandle)
+		except TypeError:
+			# HACK Newer python-telepathy way
+			telepathy.server.ChannelTypeText.__init__(self, connection, manager, props)
 		self._nextRecievedId = 0
 		self._lastMessageTimestamp = datetime.datetime(1, 1, 1)
 
-		self._otherHandle = h
+		self._otherHandle = contactHandle
 
+		self._callback = coroutines.func_sink(
+			coroutines.expand_positional(
+				self._on_conversations_updated
+			)
+		)
 		self._conn.session.conversations.updateSignalHandler.register_sink(
-			self._on_conversations_updated
+			self._callback
 		)
 
 		# The only reason there should be anything in the conversation is if
 		# its new, so report it all
 		try:
-			conversation = self._conn.session.conversations.get_conversation(self._contactKey)
+			mergedConversations = self._conn.session.conversations.get_conversation(self._contactKey)
 		except KeyError:
 			pass
 		else:
-			self._report_conversation(conversation)
+			self._report_conversation(mergedConversations)
 
 	@gtk_toolbox.log_exception(_moduleLogger)
 	def Send(self, messageType, text):
@@ -43,64 +56,92 @@ class TextChannel(telepathy.server.ChannelTypeText):
 			raise telepathy.errors.NotImplemented("Unhandled message type: %r" % messageType)
 
 		self._conn.session.backend.send_sms(self._otherHandle.phoneNumber, text)
+		self._conn.session.stateMachine.reset_timers()
 
 		self.Sent(int(time.time()), messageType, text)
 
 	@gtk_toolbox.log_exception(_moduleLogger)
 	def Close(self):
-		try:
-			# Clear since the user has seen it all and it should start a new conversation
-			self._conn.session.conversations.clear_conversation(self._contactKey)
+		self.close()
 
-			self._conn.session.conversations.updateSignalHandler.unregister_sink(
-				self._on_conversations_updated
-			)
-		finally:
-			telepathy.server.ChannelTypeText.Close(self)
-			self.remove_from_connection()
+	def close(self):
+		self._conn.session.conversations.updateSignalHandler.unregister_sink(
+			self._callback
+		)
+		self._callback = None
+
+		telepathy.server.ChannelTypeText.Close(self)
+		if self._manager.channel_exists(self._props):
+			# HACK Older python-telepathy requires doing this manually
+			self._manager.remove_channel(self)
+		self.remove_from_connection()
 
 	@property
 	def _contactKey(self):
 		contactKey = self._otherHandle.contactID, self._otherHandle.phoneNumber
 		return contactKey
 
-	@coroutines.func_sink
-	@coroutines.expand_positional
 	@gobject_utils.async
 	@gtk_toolbox.log_exception(_moduleLogger)
-	def _on_conversations_updated(self, conversationIds):
+	def _on_conversations_updated(self, conv, conversationIds):
 		if self._contactKey not in conversationIds:
 			return
 		_moduleLogger.info("Incoming messages from %r for existing conversation" % (self._contactKey, ))
-		conversation = self._conn.session.conversations.get_conversation(self._contactKey)
-		self._report_conversation(conversation)
-
-	def _report_conversation(self, conversation):
-		# @bug? Check if messages sent need to be filtered out
-		completeMessageHistory = conversation["messageParts"]
-		messages = self._filter_seen_messages(completeMessageHistory)
-		self._lastMessageTimestamp = messages[-1][0]
-		formattedMessage = self._format_messages(messages)
-		self._report_new_message(formattedMessage)
-
-	def _filter_seen_messages(self, messages):
+		mergedConversations = self._conn.session.conversations.get_conversation(self._contactKey)
+		self._report_conversation(mergedConversations)
+
+	def _report_conversation(self, mergedConversations):
+		newConversations = mergedConversations.conversations
+		newConversations = self._filter_out_reported(newConversations)
+		newConversations = self._filter_out_read(newConversations)
+		newConversations = list(newConversations)
+		if not newConversations:
+			_moduleLogger.info(
+				"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 newConversations:
+			_moduleLogger.info(
+				"All incoming messages were really outbound messages for %r" % (self._contactKey, )
+			)
+			return
+
+		for newMessage in messages:
+			formattedMessage = self._format_message(newMessage)
+			self._report_new_message(formattedMessage)
+
+	def _filter_out_reported(self, conversations):
+		return (
+			conversation
+			for conversation in conversations
+			if self._lastMessageTimestamp < conversation.time
+		)
+
+	def _filter_out_read(self, conversations):
 		return (
-			message
-			for message in messages
-			if self._lastMessageTimestamp < message[0]
+			conversation
+			for conversation in conversations
+			if not conversation.isRead and not conversation.isArchived
 		)
 
-	def _format_messages(self, messages):
-		return "\n".join(message[1] for message in messages)
+	def _format_message(self, message):
+		return " ".join(part.text.strip() for part in message.body)
 
 	def _report_new_message(self, message):
 		currentReceivedId = self._nextRecievedId
 
 		timestamp = int(time.time())
 		type = telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL
-		message = message.content
 
 		_moduleLogger.info("Received message from User %r" % self._otherHandle)
-		self.Received(id, timestamp, self._otherHandle, type, 0, message)
+		self.Received(currentReceivedId, timestamp, self._otherHandle, type, 0, message)
 
 		self._nextRecievedId += 1