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 SetSimplePresence(Action):
 318
 319         def __init__(self, connAction, status, message):
 320                 super(SetSimplePresence, self).__init__()
 321                 self._connAction = connAction
 322                 self._status = status
 323                 self._message = message
 324
 325         def queue_action(self):
 326                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_SIMPLE_PRESENCE].SetPresence(
 327                         self._status,
 328                         self._message,
 329                         reply_handler = self._on_done,
 330                         error_handler = self._on_error,
 331                 )
 332
 333         def _on_done(self):
 334                 super(SetSimplePresence, self)._on_done()
 335
 336
 337 class Aliases(Action):
 338
 339         def __init__(self, connAction, handleAction):
 340                 super(Aliases, self).__init__()
 341                 self._connAction = connAction
 342                 self._handleAction = handleAction
 343
 344         def queue_action(self):
 345                 self._connAction.conn[telepathy.server.CONNECTION_INTERFACE_ALIASING].RequestAliases(
 346                         self._handleAction.handles,
 347                         reply_handler = self._on_done,
 348                         error_handler = self._on_error,
 349                 )
 350
 351         def _on_done(self, aliases):
 352                 print "\tAliases:"
 353                 for alias in aliases:
 354                         print "\t\t", alias
 355                 super(Aliases, self)._on_done()
 356
 357
 358 class Call(Action):
 359
 360         def __init__(self, connAction, chanAction, handleAction):
 361                 super(Call, self).__init__()
 362                 self._connAction = connAction
 363                 self._chanAction = chanAction
 364                 self._handleAction = handleAction
 365
 366         def queue_action(self):
 367                 self._chanAction.channel[telepathy.server.CHANNEL_TYPE_STREAMED_MEDIA].RequestStreams(
 368                         self._handleAction.handle,
 369                         [telepathy.constants.MEDIA_STREAM_TYPE_AUDIO],
 370                         reply_handler = self._on_done,
 371                         error_handler = self._on_error,
 372                 )
 373
 374         def _on_done(self, handle):
 375                 print "Call started"
 376                 super(Call, self)._on_done()
 377
 378
 379 class SendText(Action):
 380
 381         def __init__(self, connAction, chanAction, handleAction, messageType, message):
 382                 super(SendText, self).__init__()
 383                 self._connAction = connAction
 384                 self._chanAction = chanAction
 385                 self._handleAction = handleAction
 386                 self._messageType = messageType
 387                 self._message = message
 388
 389         def queue_action(self):
 390                 self._chanAction.channel[telepathy.server.CHANNEL_TYPE_TEXT].Send(
 391                         self._messageType,
 392                         self._message,
 393                         reply_handler = self._on_done,
 394                         error_handler = self._on_error,
 395                 )
 396
 397         def _on_done(self,):
 398                 print "Message sent"
 399                 super(SendText, self)._on_done()
 400
 401
 402 class Block(Action):
 403
 404         def __init__(self):
 405                 super(Block, self).__init__()
 406
 407         def queue_action(self):
 408                 print "Blocking"
 409
 410         def _on_done(self):
 411                 #super(SendText, self)._on_done()
 412                 pass
 413
 414
 415 class Disconnect(Action):
 416
 417         def __init__(self, connAction):
 418                 super(Disconnect, self).__init__()
 419                 self._connAction = connAction
 420
 421         def queue_action(self):
 422                 self._connAction.conn[telepathy.server.CONNECTION].Disconnect(
 423                         reply_handler = self._on_done,
 424                         error_handler = self._on_error,
 425                 )
 426
 427
 428 if __name__ == '__main__':
 429         loop = gobject.MainLoop()
 430
 431         reg = get_registry()
 432         cm = get_connection_manager(reg)
 433
 434         nullHandle = NullHandle()
 435
 436         dummy = DummyAction()
 437         firstAction = dummy
 438         lastAction = dummy
 439
 440         if True:
 441                 dp = DisplayParams(cm)
 442                 lastAction.append_action(dp)
 443                 lastAction = dp
 444
 445         if True:
 446                 username = sys.argv[1]
 447                 password = sys.argv[2]
 448                 forward = sys.argv[3]
 449                 con = Connect(cm, username, password, forward)
 450                 lastAction.append_action(con)
 451                 lastAction = con
 452
 453                 if True:
 454                         spo = SimplePresenceOptions(con)
 455                         lastAction.append_action(spo)
 456                         lastAction = spo
 457
 458                 if True:
 459                         uh = UserHandle(con)
 460                         lastAction.append_action(uh)
 461                         lastAction = uh
 462
 463                         ua = Aliases(con, uh)
 464                         lastAction.append_action(ua)
 465                         lastAction = ua
 466
 467                         sps = SimplePresenceStatus(con, uh)
 468                         lastAction.append_action(sps)
 469                         lastAction = sps
 470
 471                         if False:
 472                                 setdnd = SetSimplePresence(con, "dnd", "")
 473                                 lastAction.append_action(setdnd)
 474                                 lastAction = setdnd
 475
 476                                 sps = SimplePresenceStatus(con, uh)
 477                                 lastAction.append_action(sps)
 478                                 lastAction = sps
 479
 480                                 setdnd = SetSimplePresence(con, "available", "")
 481                                 lastAction.append_action(setdnd)
 482                                 lastAction = setdnd
 483
 484                                 sps = SimplePresenceStatus(con, uh)
 485                                 lastAction.append_action(sps)
 486                                 lastAction = sps
 487
 488                 if True:
 489                         rclh = RequestHandle(con, telepathy.HANDLE_TYPE_LIST, ["subscribe"])
 490                         lastAction.append_action(rclh)
 491                         lastAction = rclh
 492
 493                         rclc = RequestChannel(
 494                                 con,
 495                                 rclh,
 496                                 telepathy.CHANNEL_TYPE_CONTACT_LIST,
 497                                 telepathy.HANDLE_TYPE_LIST,
 498                         )
 499                         lastAction.append_action(rclc)
 500                         lastAction = rclc
 501
 502                         # @todo get aliases for contacts
 503
 504                 if True:
 505                         rch = RequestHandle(con, telepathy.HANDLE_TYPE_CONTACT, ["18005558355"]) #(1-800-555-TELL)
 506                         lastAction.append_action(rch)
 507                         lastAction = rch
 508
 509                         # making a phone call
 510                         if True:
 511                                 smHandle = rch
 512                                 smHandleType = telepathy.HANDLE_TYPE_CONTACT
 513                         else:
 514                                 smHandle = nullHandle
 515                                 smHandleType = telepathy.HANDLE_TYPE_NONE
 516                         rsmc = RequestChannel(
 517                                 con,
 518                                 smHandle,
 519                                 telepathy.CHANNEL_TYPE_STREAMED_MEDIA,
 520                                 smHandleType,
 521                         )
 522                         lastAction.append_action(rsmc)
 523                         lastAction = rsmc
 524
 525                         if False:
 526                                 call = Call(con, rsmc, rch)
 527                                 lastAction.append_action(call)
 528                                 lastAction = call
 529
 530                         # sending a text
 531                         rtc = RequestChannel(
 532                                 con,
 533                                 rch,
 534                                 telepathy.CHANNEL_TYPE_TEXT,
 535                                 smHandleType,
 536                         )
 537                         lastAction.append_action(rtc)
 538                         lastAction = rtc
 539
 540                         if False:
 541                                 sendtext = SendText(con, rtc, rch, telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL, "Boo!")
 542                                 lastAction.append_action(sendtext)
 543                                 lastAction = sendtext
 544
 545                 if True:
 546                         bl = Block()
 547                         lastAction.append_action(bl)
 548                         lastAction = bl
 549
 550                 dis = Disconnect(con)
 551                 lastAction.append_action(dis)
 552                 lastAction = dis
 553
 554         quitter = QuitLoop(loop)
 555         lastAction.append_action(quitter)
 556         lastAction = quitter
 557
 558         firstAction.queue_action()
 559         loop.run()