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 DBUS_PROPERTIES = 'org.freedesktop.DBus.Properties'
  13
  14
  15 def get_registry():
  16         reg = telepathy.client.ManagerRegistry()
  17         reg.LoadManagers()
  18         return reg
  19
  20
  21 def get_connection_manager(reg):
  22         cm = reg.GetManager('theonering')
  23         return cm
  24
  25
  26 class Action(object):
  27
  28         def __init__(self):
  29                 self._action = None
  30
  31         def queue_action(self):
  32                 pass
  33
  34         def append_action(self, action):
  35                 assert self._action is None
  36                 self._action = action
  37
  38         def _on_done(self):
  39                 if self._action is None:
  40                         return
  41                 self._action.queue_action()
  42
  43         def _on_error(self, error):
  44                 print error
  45
  46         def _on_generic_message(self, *args):
  47                 pass
  48
  49
  50 class DummyAction(Action):
  51
  52         def queue_action(self):
  53                 gobject.idle_add(self._on_done)
  54
  55
  56 class QuitLoop(Action):
  57
  58         def __init__(self, loop):
  59                 super(QuitLoop, self).__init__()
  60                 self._loop = loop
  61
  62         def queue_action(self):
  63                 self._loop.quit()
  64
  65
  66 class DisplayParams(Action):
  67
  68         def __init__(self, cm):
  69                 super(DisplayParams, self).__init__()
  70                 self._cm = cm
  71
  72         def queue_action(self):
  73                 self._cm[telepathy.interfaces.CONN_MGR_INTERFACE].GetParameters(
  74                         'sip',
  75                         reply_handler = self._on_done,
  76                         error_handler = self._on_error,
  77                 )
  78
  79         def _on_done(self, params):
  80                 print "Connection Parameters:"
  81                 for name, flags, signature, default in params:
  82                         print "\t%s (%s)" % (name, signature),
  83
  84                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_REQUIRED:
  85                                 print "required",
  86                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_REGISTER:
  87                                 print "register",
  88                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_SECRET:
  89                                 print "secret",
  90                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_DBUS_PROPERTY:
  91                                 print "dbus-property",
  92                         if flags & telepathy.constants.CONN_MGR_PARAM_FLAG_HAS_DEFAULT:
  93                                 print "has-default(%s)" % default,
  94
  95                         print ""
  96                 super(DisplayParams, self)._on_done()
  97
  98
  99 class Connect(Action):
 100
 101         def __init__(self, cm, username, password, forward):
 102                 super(Connect, self).__init__()
 103                 self._cm = cm
 104                 self._conn = None
 105                 self._username = username
 106                 self._password = password
 107                 self._forward = forward
 108
 109         @property
 110         def conn(self):
 111                 return self._conn
 112
 113         def queue_action(self):
 114                 self._cm[telepathy.server.CONNECTION_MANAGER].RequestConnection(
 115                         'sip',
 116                         {
 117                                 'username':  self._username,
 118                                 'password': self._password,
 119                                 'forward':  self._forward,
 120                         },
 121                         reply_handler = self._on_connection_requested,
 122                         error_handler = self._on_error,
 123                 )
 124
 125         def _on_connection_requested(self, busName, objectPath):
 126                 self._conn = telepathy.client.Connection(busName, objectPath)
 127                 self._conn[telepathy.server.CONNECTION].connect_to_signal(
 128                         'StatusChanged',
 129                         self._on_change,
 130                 )
 131                 self._conn[telepathy.server.CONNECTION].Connect(
 132                         reply_handler = self._on_generic_message,
 133                         error_handler = self._on_error,
 134                 )
 135
 136         def _on_done(self):
 137                 super(Connect, self)._on_done()
 138
 139         def _on_change(self, status, reason):
 140                 if status == telepathy.constants.CONNECTION_STATUS_DISCONNECTED:
 141                         print "Disconnected!"
 142                         self._conn = None
 143                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTED:
 144                         print "Connected"
 145                         self._on_done()
 146                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTING:
 147                         print "Connecting"
 148                 else:
 149                         print "Status: %r" % status
 150
 151
 152 class SimplePresenceOptions(Action):
 153
 154         def __init__(self, connAction):
 155                 super(SimplePresenceOptions, self).__init__()
 156                 self._connAction = connAction
 157
 158         def queue_action(self):
 159                 self._connAction.conn[DBUS_PROPERTIES].Get(
 160                         telepathy.server.CONNECTION_INTERFACE_SIMPLE_PRESENCE,
 161                         'Statuses',
 162                         reply_handler = self._on_done,
 163                         error_handler = self._on_error,
 164                 )
 165
 166         def _on_done(self, statuses):
 167                 print "\tAvailable Statuses"
 168                 for (key, value) in statuses.iteritems():
 169                         print "\t\t - %s" % key
 170                 super(SimplePresenceOptions, self)._on_done()
 171
 172
 173 class NullHandle(object):
 174
 175         @property
 176         def handle(self):
 177                 return 0
 178
 179         @property
 180         def handles(self):
 181                 return []
 182
 183
 184 class UserHandle(Action):
 185
 186         def __init__(self, connAction):
 187                 super(UserHandle, self).__init__()
 188                 self._connAction = connAction
 189                 self._handle = None
 190
 191         @property
 192         def handle(self):
 193                 return self._handle
 194
 195         @property
 196         def handles(self):
 197                 return [self._handle]
 198
 199         def queue_action(self):
 200                 self._connAction.conn[telepathy.server.CONNECTION].GetSelfHandle(
 201                         reply_handler = self._on_done,
 202                         error_handler = self._on_error,
 203                 )
 204
 205         def _on_done(self, handle):
 206                 self._handle = handle
 207                 super(UserHandle, self)._on_done()
 208
 209
 210 class RequestHandle(Action):
 211
 212         def __init__(self, connAction, handleType, handleNames):
 213                 super(RequestHandle, self).__init__()
 214                 self._connAction = connAction
 215                 self._handle = None
 216                 self._handleType = handleType
 217                 self._handleNames = handleNames
 218
 219         @property
 220         def handle(self):
 221                 return self._handle
 222
 223         @property
 224         def handles(self):
 225                 return [self._handle]
 226
 227         def queue_action(self):
 228                 self._connAction.conn[telepathy.server.CONNECTION].RequestHandles(
 229                         self._handleType,
 230                         self._handleNames,
 231                         reply_handler = self._on_done,
 232                         error_handler = self._on_error,
 233                 )
 234
 235         def _on_done(self, handles):
 236                 self._handle = handles[0]
 237                 super(RequestHandle, self)._on_done()
 238
 239
 240 class RequestChannel(Action):
 241
 242         def __init__(self, connAction, handleAction, channelType, handleType):
 243                 super(RequestChannel, self).__init__()
 244                 self._connAction = connAction
 245                 self._handleAction = handleAction
 246                 self._channel = None
 247                 self._channelType = channelType
 248                 self._handleType = handleType
 249
 250         @property
 251         def channel(self):
 252                 return self._channel
 253
 254         def queue_action(self):
 255                 self._connAction.conn[telepathy.server.CONNECTION].RequestChannel(
 256                         self._channelType,
 257                         self._handleType,
 258                         self._handleAction.handle,
 259                         True,
 260                         reply_handler = self._on_done,
 261                         error_handler = self._on_error,
 262                 )
 263
 264         def _on_done(self, channelObjectPath):
 265                 self._channel = channelObjectPath
 266                 super(RequestChannel, self)._on_done()
 267
 268
 269 class ContactHandles(Action):
 270
 271         def __init__(self, connAction):
 272                 super(UserHandle, self).__init__()
 273                 self._connAction = connAction
 274                 self._handles = []
 275
 276         @property
 277         def handles(self):
 278                 return self._handles
 279
 280         def queue_action(self):
 281                 pass
 282
 283         def _on_done(self, handle):
 284                 super(UserHandle, self)._on_done()
 285
 286
 287 class SimplePresenceStatus(Action):
 288
 289         def __init__(self, connAction, handleAction):
 290                 super(SimplePresenceStatus, self).__init__()
 291                 self._connAction = connAction
 292                 self._handleAction = handleAction
 293
 294         def queue_action(self):
 295                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_SIMPLE_PRESENCE].GetPresences(
 296                         self._handleAction.handles,
 297                         reply_handler = self._on_done,
 298                         error_handler = self._on_error,
 299                 )
 300
 301         def _on_done(self, aliases):
 302                 print "\tPresences:"
 303                 for hid, (presenceType, presence, presenceMessage) in aliases.iteritems():
 304                         print "\t\t%s:" % hid, presenceType, presence, presenceMessage
 305                 super(SimplePresenceStatus, self)._on_done()
 306
 307
 308 class Aliases(Action):
 309
 310         def __init__(self, connAction, handleAction):
 311                 super(Aliases, self).__init__()
 312                 self._connAction = connAction
 313                 self._handleAction = handleAction
 314
 315         def queue_action(self):
 316                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_ALIASING].RequestAliases(
 317                         self._handleAction.handles,
 318                         reply_handler = self._on_done,
 319                         error_handler = self._on_error,
 320                 )
 321
 322         def _on_done(self, aliases):
 323                 print "\tAliases:"
 324                 for alias in aliases:
 325                         print "\t\t", alias
 326                 super(Aliases, self)._on_done()
 327
 328
 329 class Disconnect(Action):
 330
 331         def __init__(self, connAction):
 332                 super(Disconnect, self).__init__()
 333                 self._connAction = connAction
 334
 335         def queue_action(self):
 336                 self._connAction.conn[telepathy.server.CONNECTION].Disconnect(
 337                         reply_handler = self._on_done,
 338                         error_handler = self._on_error,
 339                 )
 340
 341
 342 if __name__ == '__main__':
 343         loop = gobject.MainLoop()
 344
 345         reg = get_registry()
 346         cm = get_connection_manager(reg)
 347
 348         nullHandle = NullHandle()
 349
 350         dummy = DummyAction()
 351         firstAction = dummy
 352         lastAction = dummy
 353
 354         if True:
 355                 dp = DisplayParams(cm)
 356                 lastAction.append_action(dp)
 357                 lastAction = dp
 358
 359         if True:
 360                 username = sys.argv[1]
 361                 password = sys.argv[2]
 362                 forward = sys.argv[3]
 363                 con = Connect(cm, username, password, forward)
 364                 lastAction.append_action(con)
 365                 lastAction = con
 366
 367                 if True:
 368                         spo = SimplePresenceOptions(con)
 369                         lastAction.append_action(spo)
 370                         lastAction = spo
 371
 372                 if True:
 373                         uh = UserHandle(con)
 374                         lastAction.append_action(uh)
 375                         lastAction = uh
 376
 377                         ua = Aliases(con, uh)
 378                         lastAction.append_action(ua)
 379                         lastAction = ua
 380
 381                         sps = SimplePresenceStatus(con, uh)
 382                         lastAction.append_action(sps)
 383                         lastAction = sps
 384
 385                 if True:
 386                         rclh = RequestHandle(con, telepathy.HANDLE_TYPE_LIST, ["subscribe"])
 387                         lastAction.append_action(rclh)
 388                         lastAction = rclh
 389
 390                         rclc = RequestChannel(
 391                                 con,
 392                                 rclh,
 393                                 telepathy.CHANNEL_TYPE_CONTACT_LIST,
 394                                 telepathy.HANDLE_TYPE_LIST,
 395                         )
 396                         lastAction.append_action(rclc)
 397                         lastAction = rclc
 398
 399                         # @todo get aliases for contacts
 400
 401                 if True:
 402                         rch = RequestHandle(con, telepathy.HANDLE_TYPE_CONTACT, ["18005558355"]) #(1-800-555-TELL)
 403                         lastAction.append_action(rch)
 404                         lastAction = rch
 405
 406                         if True:
 407                                 smHandle = rch
 408                                 smHandleType = telepathy.HANDLE_TYPE_CONTACT
 409                         else:
 410                                 smHandle = nullHandle
 411                                 smHandleType = telepathy.HANDLE_TYPE_NONE
 412                         rsmc = RequestChannel(
 413                                 con,
 414                                 smHandle,
 415                                 telepathy.CHANNEL_TYPE_STREAMED_MEDIA,
 416                                 smHandleType,
 417                         )
 418                         lastAction.append_action(rsmc)
 419                         lastAction = rsmc
 420
 421                         # @todo call contact
 422
 423                 dis = Disconnect(con)
 424                 lastAction.append_action(dis)
 425                 lastAction = dis
 426
 427         quitter = QuitLoop(loop)
 428         lastAction.append_action(quitter)
 429         lastAction = quitter
 430
 431         firstAction.queue_action()
 432         loop.run()