git.maemo.org Git - theonering/blob - hand_tests/generic.py

   1 #!/usr/bin/env python
   2
   3 import sys
   4
   5 import gobject
   6 import dbus.mainloop.glib
   7 dbus.mainloop.glib.DBusGMainLoop(set_as_default = True)
   8
   9 import telepathy
  10
  11
  12 def get_registry():
  13         reg = telepathy.client.ManagerRegistry()
  14         reg.LoadManagers()
  15         return reg
  16
  17
  18 def get_connection_manager(reg):
  19         cm = reg.GetManager('theonering')
  20         return cm
  21
  22
  23 class Action(object):
  24
  25         def __init__(self):
  26                 self._action = None
  27
  28         def queue_action(self):
  29                 pass
  30
  31         def append_action(self, action):
  32                 assert self._action is None
  33                 self._action = action
  34
  35         def _on_done(self):
  36                 if self._action is None:
  37                         return
  38                 self._action.queue_action()
  39
  40         def _on_error(self, error):
  41                 print error
  42
  43         def _on_generic_message(self, *args):
  44                 pass
  45
  46
  47 class DummyAction(Action):
  48
  49         def queue_action(self):
  50                 gobject.idle_add(self._on_done)
  51
  52
  53 class QuitLoop(Action):
  54
  55         def __init__(self, loop):
  56                 super(QuitLoop, self).__init__()
  57                 self._loop = loop
  58
  59         def queue_action(self):
  60                 self._loop.quit()
  61
  62
  63 class DisplayParams(Action):
  64
  65         def __init__(self, cm):
  66                 super(DisplayParams, self).__init__()
  67                 self._cm = cm
  68
  69         def queue_action(self):
  70                 self._cm[telepathy.interfaces.CONN_MGR_INTERFACE].GetParameters(
  71                         'sip',
  72                         reply_handler = self._on_done,
  73                         error_handler = self._on_error,
  74                 )
  75
  76         def _on_done(self, params):
  77                 print "Connection Parameters:"
  78                 for name, flags, signature, default in params:
  79                         print "\t%s (%s)" % (name, signature),
  80
  81                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_REQUIRED:
  82                                 print "required",
  83                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_REGISTER:
  84                                 print "register",
  85                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_SECRET:
  86                                 print "secret",
  87                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_DBUS_PROPERTY:
  88                                 print "dbus-property",
  89                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_HAS_DEFAULT:
  90                                 print "has-default(%s)" % default,
  91
  92                         print ""
  93                 super(DisplayParams, self)._on_done()
  94
  95
  96 class Connect(Action):
  97
  98         def __init__(self, cm, username, password, forward):
  99                 super(Connect, self).__init__()
 100                 self._cm = cm
 101                 self._conn = None
 102                 self._username = username
 103                 self._password = password
 104                 self._forward = forward
 105
 106         @property
 107         def conn(self):
 108                 return self._conn
 109
 110         def queue_action(self):
 111                 self._cm[telepathy.server.CONNECTION_MANAGER].RequestConnection(
 112                         'sip',
 113                         {
 114                                 'username':  self._username,
 115                                 'password': self._password,
 116                                 'forward':  self._forward,
 117                         },
 118                         reply_handler = self._on_connection_requested,
 119                         error_handler = self._on_error,
 120                 )
 121
 122         def _on_connection_requested(self, busName, objectPath):
 123                 self._conn = telepathy.client.Connection(busName, objectPath)
 124                 self._conn[telepathy.server.CONNECTION].connect_to_signal(
 125                         'StatusChanged',
 126                         self._on_change,
 127                 )
 128                 self._conn[telepathy.server.CONNECTION].Connect(
 129                         reply_handler = self._on_generic_message,
 130                         error_handler = self._on_error,
 131                 )
 132
 133         def _on_done(self):
 134                 super(Connect, self)._on_done()
 135
 136         def _on_change(self, status, reason):
 137                 if status == telepathy.constants.CONNECTION_STATUS_DISCONNECTED:
 138                         print "Disconnected!"
 139                         self._conn = None
 140                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTED:
 141                         print "Connected"
 142                         self._on_done()
 143                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTING:
 144                         print "Connecting"
 145                 else:
 146                         print "Status: %r" % status
 147
 148
 149 class UserHandle(Action):
 150
 151         def __init__(self, connAction):
 152                 super(UserHandle, self).__init__()
 153                 self._connAction = connAction
 154                 self._handle = None
 155
 156         @property
 157         def handle(self):
 158                 return self._handle
 159
 160         @property
 161         def handles(self):
 162                 return [self._handle]
 163
 164         def queue_action(self):
 165                 self._connAction.conn[telepathy.server.CONNECTION].GetSelfHandle(
 166                         reply_handler = self._on_done,
 167                         error_handler = self._on_error,
 168                 )
 169
 170         def _on_done(self, handle):
 171                 self._handle = handle
 172                 super(UserHandle, self)._on_done()
 173
 174
 175 class RequestContactListHandle(Action):
 176
 177         def __init__(self, connAction):
 178                 super(RequestContactListHandle, self).__init__()
 179                 self._connAction = connAction
 180                 self._handle = None
 181
 182         @property
 183         def handle(self):
 184                 return self._handle
 185
 186         @property
 187         def handles(self):
 188                 return [self._handle]
 189
 190         def queue_action(self):
 191                 pass
 192
 193         def _on_done(self, handles):
 194                 self._handle = handles[0]
 195                 super(RequestContactListHandle, self)._on_done()
 196
 197
 198 class RequestContactListChannel(Action):
 199
 200         def __init__(self, connAction, handleAction):
 201                 super(RequestContactListChannel, self).__init__()
 202                 self._connAction = connAction
 203                 self._handleAction = handleAction
 204                 self._channel = None
 205
 206         @property
 207         def channel(self):
 208                 return self._channel
 209
 210         def queue_action(self):
 211                 pass
 212
 213         def _on_done(self, channel):
 214                 self._channel = channel
 215                 super(RequestContactListChannel, self)._on_done()
 216
 217
 218 class ContactHandles(Action):
 219
 220         def __init__(self, connAction):
 221                 super(UserHandle, self).__init__()
 222                 self._connAction = connAction
 223                 self._handles = []
 224
 225         @property
 226         def handles(self):
 227                 return self._handles
 228
 229         def queue_action(self):
 230                 pass
 231
 232         def _on_done(self, handle):
 233                 super(UserHandle, self)._on_done()
 234
 235
 236 class Aliases(Action):
 237
 238         def __init__(self, connAction, handleAction):
 239                 super(Aliases, self).__init__()
 240                 self._connAction = connAction
 241                 self._handleAction = handleAction
 242
 243         def queue_action(self):
 244                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_ALIASING].RequestAliases(
 245                         self._handleAction.handles,
 246                         reply_handler = self._on_done,
 247                         error_handler = self._on_error,
 248                 )
 249
 250         def _on_done(self, aliases):
 251                 print "\tAliases:"
 252                 for alias in aliases:
 253                         print "\t\t", alias
 254                 super(Aliases, self)._on_done()
 255
 256
 257 class Disconnect(Action):
 258
 259         def __init__(self, connAction):
 260                 super(Disconnect, self).__init__()
 261                 self._connAction = connAction
 262
 263         def queue_action(self):
 264                 self._connAction.conn[telepathy.server.CONNECTION].Disconnect(
 265                         reply_handler = self._on_done,
 266                         error_handler = self._on_error,
 267                 )
 268
 269
 270 if __name__ == '__main__':
 271         loop = gobject.MainLoop()
 272
 273         reg = get_registry()
 274         cm = get_connection_manager(reg)
 275
 276         dummy = DummyAction()
 277         firstAction = dummy
 278         lastAction = dummy
 279
 280         if True:
 281                 dp = DisplayParams(cm)
 282                 lastAction.append_action(dp)
 283                 lastAction = dp
 284
 285         if True:
 286                 username = sys.argv[1]
 287                 password = sys.argv[2]
 288                 forward = sys.argv[3]
 289                 con = Connect(cm, username, password, forward)
 290                 lastAction.append_action(con)
 291                 lastAction = con
 292
 293                 if True:
 294                         uh = UserHandle(con)
 295                         lastAction.append_action(uh)
 296                         lastAction = uh
 297
 298                         ua = Aliases(con, uh)
 299                         lastAction.append_action(ua)
 300                         lastAction = ua
 301
 302                 dis = Disconnect(con)
 303                 lastAction.append_action(dis)
 304                 lastAction = dis
 305
 306         quitter = QuitLoop(loop)
 307         lastAction.append_action(quitter)
 308         lastAction = quitter
 309
 310         firstAction.queue_action()
 311         loop.run()