git.maemo.org Git - theonering/blob - src/channel/debug_prompt.py

   1 import cmd
   2 import StringIO
   3 import time
   4 import datetime
   5 import logging
   6
   7 import telepathy
   8
   9 import gtk_toolbox
  10
  11
  12 _moduleLogger = logging.getLogger("channel.text")
  13
  14
  15 class DebugPromptChannel(telepathy.server.ChannelTypeText, cmd.Cmd):
  16         """
  17         Look into implementing ChannelInterfaceMessages for rich text formatting
  18         """
  19
  20         def __init__(self, connection, manager, props, contactHandle):
  21                 self.__manager = manager
  22                 self.__props = props
  23
  24                 cmd.Cmd.__init__(self, "Debug Prompt")
  25                 self.use_rawinput = False
  26                 try:
  27                         # HACK Older python-telepathy way
  28                         telepathy.server.ChannelTypeText.__init__(self, connection, contactHandle)
  29                 except TypeError:
  30                         # HACK Newer python-telepathy way
  31                         telepathy.server.ChannelTypeText.__init__(self, connection, manager, props)
  32                 self.__nextRecievedId = 0
  33                 self.__lastMessageTimestamp = datetime.datetime(1, 1, 1)
  34
  35                 self.__otherHandle = contactHandle
  36
  37         @gtk_toolbox.log_exception(_moduleLogger)
  38         def Send(self, messageType, text):
  39                 if messageType != telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL:
  40                         raise telepathy.errors.NotImplemented("Unhandled message type: %r" % messageType)
  41
  42                 self.Sent(int(time.time()), messageType, text)
  43
  44                 oldStdin, oldStdout = self.stdin, self.stdout
  45                 try:
  46                         self.stdin = currentStdin = StringIO.StringIO()
  47                         self.stdout = currentStdout = StringIO.StringIO()
  48                         self.onecmd(text)
  49                 finally:
  50                         self.stdin, self.stdout = oldStdin, oldStdout
  51
  52                 self._report_new_message(currentStdout.getvalue())
  53
  54         @gtk_toolbox.log_exception(_moduleLogger)
  55         def Close(self):
  56                 self.close()
  57
  58         def close(self):
  59                 telepathy.server.ChannelTypeText.Close(self)
  60                 if self.__manager.channel_exists(self.__props):
  61                         # HACK Older python-telepathy requires doing this manually
  62                         self.__manager.remove_channel(self)
  63                 self.remove_from_connection()
  64
  65         def _report_new_message(self, message):
  66                 currentReceivedId = self.__nextRecievedId
  67
  68                 timestamp = int(time.time())
  69                 type = telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL
  70
  71                 self.Received(currentReceivedId, timestamp, self.__otherHandle, type, 0, message.strip())
  72
  73                 self.__nextRecievedId += 1
  74
  75         def do_reset_state_machine(self, args):
  76                 if args:
  77                         self._report_new_message("No arguments supported")
  78                         return
  79
  80                 try:
  81                         for machine in self._conn.session.stateMachine._machines:
  82                                 machine.reset_timers()
  83                 except Exception, e:
  84                         self._report_new_message(str(e))
  85
  86         def do_get_state(self, args):
  87                 if args:
  88                         self._report_new_message("No arguments supported")
  89                         return
  90
  91                 try:
  92                         state = self._conn.session.stateMachine.state
  93                         self._report_new_message(str(state))
  94                 except Exception, e:
  95                         self._report_new_message(str(e))
  96
  97         def do_is_authed(self, args):
  98                 if args:
  99                         self._report_new_message("No arguments supported")
 100                         return
 101
 102                 try:
 103                         isAuthed = self._conn.session.backend.is_authed()
 104                         self._report_new_message(str(isAuthed))
 105                 except Exception, e:
 106                         self._report_new_message(str(e))
 107
 108         def do_is_dnd(self, args):
 109                 if args:
 110                         self._report_new_message("No arguments supported")
 111                         return
 112
 113                 try:
 114                         isDnd = self._conn.session.backend.is_dnd()
 115                         self._report_new_message(str(isDnd))
 116                 except Exception, e:
 117                         self._report_new_message(str(e))
 118
 119         def do_get_account_number(self, args):
 120                 if args:
 121                         self._report_new_message("No arguments supported")
 122                         return
 123
 124                 try:
 125                         number = self._conn.session.backend.get_account_number()
 126                         self._report_new_message(number)
 127                 except Exception, e:
 128                         self._report_new_message(str(e))
 129
 130         def do_get_callback_numbers(self, args):
 131                 if args:
 132                         self._report_new_message("No arguments supported")
 133                         return
 134
 135                 try:
 136                         numbers = self._conn.session.backend.get_callback_numbers()
 137                         numbersDisplay = "\n".join(
 138                                 "%s: %s" % (name, number)
 139                                 for (number, name) in numbers.iteritems()
 140                         )
 141                         self._report_new_message(numbersDisplay)
 142                 except Exception, e:
 143                         self._report_new_message(str(e))
 144
 145         def do_get_callback_number(self, args):
 146                 if args:
 147                         self._report_new_message("No arguments supported")
 148                         return
 149
 150                 try:
 151                         number = self._conn.session.backend.get_callback_number()
 152                         self._report_new_message(number)
 153                 except Exception, e:
 154                         self._report_new_message(str(e))
 155
 156         def do_call(self, args):
 157                 if len(args) != 1:
 158                         self._report_new_message("Must specify the phone number and only the phone nunber")
 159                         return
 160
 161                 try:
 162                         number = args[0]
 163                         self._conn.session.backend.call(number)
 164                 except Exception, e:
 165                         self._report_new_message(str(e))
 166
 167         def do_send_sms(self, args):
 168                 if 1 < len(args):
 169                         self._report_new_message("Must specify the phone number and then message")
 170                         return
 171
 172                 try:
 173                         number = args[0]
 174                         message = " ".join(args[1:])
 175                         self._conn.session.backend.send_sms(number, message)
 176                 except Exception, e:
 177                         self._report_new_message(str(e))