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
 105                 self._conn = None
 106                 self._serviceName = None
 107
 108                 self._username = username
 109                 self._password = password
 110                 self._forward = forward
 111
 112         @property
 113         def conn(self):
 114                 return self._conn
 115
 116         @property
 117         def serviceName(self):
 118                 return self._serviceName
 119
 120         def queue_action(self):
 121                 self._cm[telepathy.server.CONNECTION_MANAGER].RequestConnection(
 122                         'sip',
 123                         {
 124                                 'username':  self._username,
 125                                 'password': self._password,
 126                                 'forward':  self._forward,
 127                         },
 128                         reply_handler = self._on_connection_requested,
 129                         error_handler = self._on_error,
 130                 )
 131
 132         def _on_connection_requested(self, busName, objectPath):
 133                 self._serviceName = busName
 134                 self._conn = telepathy.client.Connection(busName, objectPath)
 135                 self._conn[telepathy.server.CONNECTION].connect_to_signal(
 136                         'StatusChanged',
 137                         self._on_change,
 138                 )
 139                 self._conn[telepathy.server.CONNECTION].Connect(
 140                         reply_handler = self._on_generic_message,
 141                         error_handler = self._on_error,
 142                 )
 143
 144         def _on_done(self):
 145                 super(Connect, self)._on_done()
 146
 147         def _on_change(self, status, reason):
 148                 if status == telepathy.constants.CONNECTION_STATUS_DISCONNECTED:
 149                         print "Disconnected!"
 150                         self._conn = None
 151                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTED:
 152                         print "Connected"
 153                         self._on_done()
 154                 elif status == telepathy.constants.CONNECTION_STATUS_CONNECTING:
 155                         print "Connecting"
 156                 else:
 157                         print "Status: %r" % status
 158
 159
 160 class SimplePresenceOptions(Action):
 161
 162         def __init__(self, connAction):
 163                 super(SimplePresenceOptions, self).__init__()
 164                 self._connAction = connAction
 165
 166         def queue_action(self):
 167                 self._connAction.conn[DBUS_PROPERTIES].Get(
 168                         telepathy.server.CONNECTION_INTERFACE_SIMPLE_PRESENCE,
 169                         'Statuses',
 170                         reply_handler = self._on_done,
 171                         error_handler = self._on_error,
 172                 )
 173
 174         def _on_done(self, statuses):
 175                 print "\tAvailable Statuses"
 176                 for (key, value) in statuses.iteritems():
 177                         print "\t\t - %s" % key
 178                 super(SimplePresenceOptions, self)._on_done()
 179
 180
 181 class NullHandle(object):
 182
 183         @property
 184         def handle(self):
 185                 return 0
 186
 187         @property
 188         def handles(self):
 189                 return []
 190
 191
 192 class UserHandle(Action):
 193
 194         def __init__(self, connAction):
 195                 super(UserHandle, self).__init__()
 196                 self._connAction = connAction
 197                 self._handle = None
 198
 199         @property
 200         def handle(self):
 201                 return self._handle
 202
 203         @property
 204         def handles(self):
 205                 return [self._handle]
 206
 207         def queue_action(self):
 208                 self._connAction.conn[telepathy.server.CONNECTION].GetSelfHandle(
 209                         reply_handler = self._on_done,
 210                         error_handler = self._on_error,
 211                 )
 212
 213         def _on_done(self, handle):
 214                 self._handle = handle
 215                 super(UserHandle, self)._on_done()
 216
 217
 218 class RequestHandle(Action):
 219
 220         def __init__(self, connAction, handleType, handleNames):
 221                 super(RequestHandle, self).__init__()
 222                 self._connAction = connAction
 223                 self._handle = None
 224                 self._handleType = handleType
 225                 self._handleNames = handleNames
 226
 227         @property
 228         def handle(self):
 229                 return self._handle
 230
 231         @property
 232         def handles(self):
 233                 return [self._handle]
 234
 235         def queue_action(self):
 236                 self._connAction.conn[telepathy.server.CONNECTION].RequestHandles(
 237                         self._handleType,
 238                         self._handleNames,
 239                         reply_handler = self._on_done,
 240                         error_handler = self._on_error,
 241                 )
 242
 243         def _on_done(self, handles):
 244                 self._handle = handles[0]
 245                 super(RequestHandle, self)._on_done()
 246
 247
 248 class RequestChannel(Action):
 249
 250         def __init__(self, connAction, handleAction, channelType, handleType):
 251                 super(RequestChannel, self).__init__()
 252                 self._connAction = connAction
 253                 self._handleAction = handleAction
 254                 self._channel = None
 255                 self._channelType = channelType
 256                 self._handleType = handleType
 257
 258         @property
 259         def channel(self):
 260                 return self._channel
 261
 262         def queue_action(self):
 263                 self._connAction.conn[telepathy.server.CONNECTION].RequestChannel(
 264                         self._channelType,
 265                         self._handleType,
 266                         self._handleAction.handle,
 267                         True,
 268                         reply_handler = self._on_done,
 269                         error_handler = self._on_error,
 270                 )
 271
 272         def _on_done(self, channelObjectPath):
 273                 self._channel = telepathy.client.Channel(self._connAction.serviceName, channelObjectPath)
 274                 super(RequestChannel, self)._on_done()
 275
 276
 277 class ContactHandles(Action):
 278
 279         def __init__(self, connAction, chanAction):
 280                 super(ContactHandles, self).__init__()
 281                 self._connAction = connAction
 282                 self._chanAction = chanAction
 283                 self._handles = []
 284
 285         @property
 286         def handles(self):
 287                 return self._handles
 288
 289         def queue_action(self):
 290                 pass
 291
 292         def _on_done(self, handle):
 293                 super(ContactHandles, self)._on_done()
 294
 295
 296 class SimplePresenceStatus(Action):
 297
 298         def __init__(self, connAction, handleAction):
 299                 super(SimplePresenceStatus, self).__init__()
 300                 self._connAction = connAction
 301                 self._handleAction = handleAction
 302
 303         def queue_action(self):
 304                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_SIMPLE_PRESENCE].GetPresences(
 305                         self._handleAction.handles,
 306                         reply_handler = self._on_done,
 307                         error_handler = self._on_error,
 308                 )
 309
 310         def _on_done(self, aliases):
 311                 print "\tPresences:"
 312                 for hid, (presenceType, presence, presenceMessage) in aliases.iteritems():
 313                         print "\t\t%s:" % hid, presenceType, presence, presenceMessage
 314                 super(SimplePresenceStatus, self)._on_done()
 315
 316
 317 class Aliases(Action):
 318
 319         def __init__(self, connAction, handleAction):
 320                 super(Aliases, self).__init__()
 321                 self._connAction = connAction
 322                 self._handleAction = handleAction
 323
 324         def queue_action(self):
 325                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_ALIASING].RequestAliases(
 326                         self._handleAction.handles,
 327                         reply_handler = self._on_done,
 328                         error_handler = self._on_error,
 329                 )
 330
 331         def _on_done(self, aliases):
 332                 print "\tAliases:"
 333                 for alias in aliases:
 334                         print "\t\t", alias
 335                 super(Aliases, self)._on_done()
 336
 337
 338 class Call(Action):
 339
 340         def __init__(self, connAction, chanAction, handleAction):
 341                 super(Call, self).__init__()
 342                 self._connAction = connAction
 343                 self._chanAction = chanAction
 344                 self._handleAction = handleAction
 345
 346         def queue_action(self):
 347                 self._chanAction.channel[telepathy.server.CHANNEL_TYPE_STREAMED_MEDIA].RequestStreams(
 348                         self._handleAction.handle,
 349                         [telepathy.constants.MEDIA_STREAM_TYPE_AUDIO],
 350                         reply_handler = self._on_done,
 351                         error_handler = self._on_error,
 352                 )
 353
 354         def _on_done(self, handle):
 355                 print "Call started"
 356                 super(Call, self)._on_done()
 357
 358
 359 class Disconnect(Action):
 360
 361         def __init__(self, connAction):
 362                 super(Disconnect, self).__init__()
 363                 self._connAction = connAction
 364
 365         def queue_action(self):
 366                 self._connAction.conn[telepathy.server.CONNECTION].Disconnect(
 367                         reply_handler = self._on_done,
 368                         error_handler = self._on_error,
 369                 )
 370
 371
 372 if __name__ == '__main__':
 373         loop = gobject.MainLoop()
 374
 375         reg = get_registry()
 376         cm = get_connection_manager(reg)
 377
 378         nullHandle = NullHandle()
 379
 380         dummy = DummyAction()
 381         firstAction = dummy
 382         lastAction = dummy
 383
 384         if True:
 385                 dp = DisplayParams(cm)
 386                 lastAction.append_action(dp)
 387                 lastAction = dp
 388
 389         if True:
 390                 username = sys.argv[1]
 391                 password = sys.argv[2]
 392                 forward = sys.argv[3]
 393                 con = Connect(cm, username, password, forward)
 394                 lastAction.append_action(con)
 395                 lastAction = con
 396
 397                 if True:
 398                         spo = SimplePresenceOptions(con)
 399                         lastAction.append_action(spo)
 400                         lastAction = spo
 401
 402                 if True:
 403                         uh = UserHandle(con)
 404                         lastAction.append_action(uh)
 405                         lastAction = uh
 406
 407                         ua = Aliases(con, uh)
 408                         lastAction.append_action(ua)
 409                         lastAction = ua
 410
 411                         sps = SimplePresenceStatus(con, uh)
 412                         lastAction.append_action(sps)
 413                         lastAction = sps
 414
 415                 if True:
 416                         rclh = RequestHandle(con, telepathy.HANDLE_TYPE_LIST, ["subscribe"])
 417                         lastAction.append_action(rclh)
 418                         lastAction = rclh
 419
 420                         rclc = RequestChannel(
 421                                 con,
 422                                 rclh,
 423                                 telepathy.CHANNEL_TYPE_CONTACT_LIST,
 424                                 telepathy.HANDLE_TYPE_LIST,
 425                         )
 426                         lastAction.append_action(rclc)
 427                         lastAction = rclc
 428
 429                         # @todo get aliases for contacts
 430
 431                 if True:
 432                         rch = RequestHandle(con, telepathy.HANDLE_TYPE_CONTACT, ["18005558355"]) #(1-800-555-TELL)
 433                         lastAction.append_action(rch)
 434                         lastAction = rch
 435
 436                         if True:
 437                                 smHandle = rch
 438                                 smHandleType = telepathy.HANDLE_TYPE_CONTACT
 439                         else:
 440                                 smHandle = nullHandle
 441                                 smHandleType = telepathy.HANDLE_TYPE_NONE
 442                         rsmc = RequestChannel(
 443                                 con,
 444                                 smHandle,
 445                                 telepathy.CHANNEL_TYPE_STREAMED_MEDIA,
 446                                 smHandleType,
 447                         )
 448                         lastAction.append_action(rsmc)
 449                         lastAction = rsmc
 450
 451                         call = Call(con, rsmc, rch)
 452                         lastAction.append_action(call)
 453                         lastAction = call
 454
 455                 dis = Disconnect(con)
 456                 lastAction.append_action(dis)
 457                 lastAction = dis
 458
 459         quitter = QuitLoop(loop)
 460         lastAction.append_action(quitter)
 461         lastAction = quitter
 462
 463         firstAction.queue_action()
 464         loop.run()