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

diff --git a/src/channel/text.py b/src/channel/text.py
index 36f506f..d2c5313 100644
--- a/src/channel/text.py
+++ b/src/channel/text.py
@@ -1,45 +1,147 @@
 import time
-import weakref
+import datetime
+import logging
 
 import telepathy
 
-import handle
+import util.go_utils as gobject_utils
+import util.coroutines as coroutines
+import gtk_toolbox
 
 
-class TheOneRingChannelText(
-		telepathy.server.ChannelTypeText,
-		telepathy.server.ChannelInterfaceGroup,
-		telepathy.server.ChannelInterfaceChatState
-	):
+_moduleLogger = logging.getLogger("channel.text")
 
-	def __init__(self, connection, conversation):
-		self._recv_id = 0
-		self._conversation = conversation
-		self._conn_ref = weakref.ref(connection)
 
-		telepathy.server.ChannelTypeText.__init__(self, connection, None)
-		telepathy.server.ChannelInterfaceGroup.__init__(self)
-		telepathy.server.ChannelInterfaceChatState.__init__(self)
+class TextChannel(telepathy.server.ChannelTypeText):
+	"""
+	Look into implementing ChannelInterfaceMessages for rich text formatting
+	"""
 
-		self.GroupFlagsChanged(telepathy.CHANNEL_GROUP_FLAG_CAN_ADD, 0)
-		self.__add_initial_participants()
+	def __init__(self, connection, manager, props, contactHandle):
+		self._manager = manager
+		self._props = props
 
-	def SetChatState(self, state):
-		if state == telepathy.CHANNEL_CHAT_STATE_COMPOSING:
-			self._conversation.send_typing_notification()
-		h = handle.create_handle(self._conn_ref(), 'connection')
-		self.ChatStateChanged(h, state)
+		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)
 
-	def Send(self, messageType, text):
-		if messageType == telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL:
-			self._conversation.send_text_message(text)
-		elif messageType == telepathy.CHANNEL_TEXT_MESSAGE_TYPE_ACTION and text == u"nudge":
-			self._conversation.send_nudge()
+		self._otherHandle = contactHandle
+
+		self._callback = coroutines.func_sink(
+			coroutines.expand_positional(
+				self._on_conversations_updated
+			)
+		)
+		self._conn.session.conversations.updateSignalHandler.register_sink(
+			self._callback
+		)
+
+		# The only reason there should be anything in the conversation is if
+		# its new, so report it all
+		try:
+			mergedConversations = self._conn.session.conversations.get_conversation(self._contactKey)
+		except KeyError:
+			pass
 		else:
-			raise telepathy.NotImplemented("Unhandled message type")
+			self._report_conversation(mergedConversations)
+
+	@gtk_toolbox.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)
+
+		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):
-		self._conversation.leave()
+		self.close()
+
+	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
+
+	@gobject_utils.async
+	@gtk_toolbox.log_exception(_moduleLogger)
+	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, ))
+		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 (
+			conversation
+			for conversation in conversations
+			if not conversation.isRead and not conversation.isArchived
+		)
+
+	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
+
+		_moduleLogger.info("Received message from User %r" % self._otherHandle)
+		self.Received(currentReceivedId, timestamp, self._otherHandle, type, 0, message)
+
+		self._nextRecievedId += 1