← Back to branch summary

~ubuntu-branches/ubuntu/utopic/telepathy-python/utopic

« back to all changes in this revision

Viewing changes to examples/tube-dbus-muc.py

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2009-06-16 11:23:44 UTC
  • mfrom: (1.1.14 upstream) (8.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090616112344-sslc71m4xns7uv8i
Tags: 0.15.8-1
* New upstream release.
* debian/control:
  - Change package priority to optional
  - Bump Standards-Version to 3.8.1 (no further changes)
  - Be more verbose in package extended description

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/tube-dbus-muc.py
3
3
import gobject
4
4
import sys
5
5
import time
6
 
import random
7
 
import pprint
8
6
from dbus.service import method, signal, Object
9
 
from dbus import Interface
 
7
from dbus import  PROPERTIES_IFACE
10
8
 
11
 
from telepathy.client import (
12
 
        Connection, Channel)
 
9
from telepathy.client import Channel
13
10
from telepathy.interfaces import (
14
 
        CONN_INTERFACE, CHANNEL_INTERFACE_GROUP, CHANNEL_TYPE_TUBES,
15
 
        CHANNEL_TYPE_TEXT)
 
11
        CONN_INTERFACE, CHANNEL_INTERFACE_GROUP,
 
12
        CHANNEL_TYPE_TEXT, CHANNEL_INTERFACE, CONNECTION_INTERFACE_REQUESTS,
 
13
        CHANNEL_INTERFACE_TUBE, CHANNEL_TYPE_DBUS_TUBE)
16
14
from telepathy.constants import (
17
15
        CONNECTION_HANDLE_TYPE_CONTACT,
18
16
        CONNECTION_HANDLE_TYPE_ROOM, CONNECTION_STATUS_CONNECTED,
19
17
        CONNECTION_STATUS_DISCONNECTED, CONNECTION_STATUS_CONNECTING,
20
 
        TUBE_TYPE_DBUS, TUBE_TYPE_STREAM, TUBE_STATE_LOCAL_PENDING,
21
 
        TUBE_STATE_REMOTE_PENDING, TUBE_STATE_OPEN)
 
18
        SOCKET_ACCESS_CONTROL_CREDENTIALS,
 
19
        TUBE_CHANNEL_STATE_LOCAL_PENDING, TUBE_CHANNEL_STATE_REMOTE_PENDING,
 
20
        TUBE_CHANNEL_STATE_OPEN, TUBE_CHANNEL_STATE_NOT_OFFERED)
22
21
 
23
22
from account import connection_from_file
24
23
from tubeconn import TubeConnection
27
26
IFACE = SERVICE
28
27
PATH = "/org/freedesktop/Telepathy/Tube/Test"
29
28
 
30
 
tube_type = {TUBE_TYPE_DBUS: "D-Bus",\
31
 
             TUBE_TYPE_STREAM: "Stream"}
32
29
 
33
 
tube_state = {TUBE_STATE_LOCAL_PENDING : 'local pending',\
34
 
              TUBE_STATE_REMOTE_PENDING : 'remote pending',\
35
 
              TUBE_STATE_OPEN : 'open'}
 
30
tube_state = {TUBE_CHANNEL_STATE_LOCAL_PENDING : 'local pending',\
 
31
              TUBE_CHANNEL_STATE_REMOTE_PENDING : 'remote pending',\
 
32
              TUBE_CHANNEL_STATE_OPEN : 'open',
 
33
              TUBE_CHANNEL_STATE_NOT_OFFERED: 'not offered'}
36
34
 
37
35
loop = None
38
36
 
39
37
class Client:
40
38
    def __init__(self, account_file, muc_id):
41
 
        self.conn = connection_from_file(account_file)
 
39
        self.conn = connection_from_file(account_file, ready_handler=self.ready_cb)
42
40
        self.muc_id = muc_id
43
41
 
44
42
        self.conn[CONN_INTERFACE].connect_to_signal('StatusChanged',
45
43
            self.status_changed_cb)
46
 
        self.conn[CONN_INTERFACE].connect_to_signal ("NewChannel",
47
 
                self.new_channel_cb)
48
44
 
49
45
        self.test = None
50
46
        self.joined = False
 
47
        self.tube = None
51
48
 
52
49
    def run(self):
53
50
        global loop
68
65
            print 'connecting'
69
66
        elif state == CONNECTION_STATUS_CONNECTED:
70
67
            print 'connected'
71
 
            self.connected_cb()
72
68
        elif state == CONNECTION_STATUS_DISCONNECTED:
73
69
            print 'disconnected'
74
70
            loop.quit()
75
71
 
76
 
    def connected_cb(self):
 
72
    def ready_cb(self, conn):
 
73
        self.conn[CONNECTION_INTERFACE_REQUESTS].connect_to_signal ("NewChannels",
 
74
                self.new_channels_cb)
 
75
 
77
76
        self.self_handle = self.conn[CONN_INTERFACE].GetSelfHandle()
78
77
 
79
78
    def join_muc(self):
82
81
        time.sleep(2)
83
82
 
84
83
        print "join muc", self.muc_id
85
 
        handle = self.conn[CONN_INTERFACE].RequestHandles(
86
 
            CONNECTION_HANDLE_TYPE_ROOM, [self.muc_id])[0]
87
 
 
88
 
        chan_path = self.conn[CONN_INTERFACE].RequestChannel(
89
 
            CHANNEL_TYPE_TEXT, CONNECTION_HANDLE_TYPE_ROOM,
90
 
            handle, True)
 
84
        chan_path, props = self.conn[CONNECTION_INTERFACE_REQUESTS].CreateChannel({
 
85
            CHANNEL_INTERFACE + ".ChannelType": CHANNEL_TYPE_TEXT,
 
86
            CHANNEL_INTERFACE + ".TargetHandleType": CONNECTION_HANDLE_TYPE_ROOM,
 
87
            CHANNEL_INTERFACE + ".TargetID": self.muc_id})
91
88
 
92
89
        self.channel_text = Channel(self.conn.dbus_proxy.bus_name, chan_path)
93
90
 
95
92
        self.channel_text[CHANNEL_INTERFACE_GROUP].connect_to_signal(
96
93
                "MembersChanged", self.text_channel_members_changed_cb)
97
94
 
98
 
        chan_path = self.conn[CONN_INTERFACE].RequestChannel(
99
 
            CHANNEL_TYPE_TUBES, CONNECTION_HANDLE_TYPE_ROOM,
100
 
            handle, True)
101
 
        self.channel_tubes = Channel(self.conn.dbus_proxy.bus_name, chan_path)
102
 
 
103
95
        if self.self_handle in self.channel_text[CHANNEL_INTERFACE_GROUP].GetMembers():
104
96
            self.joined = True
105
97
            self.muc_joined()
106
98
 
107
 
    def new_channel_cb(self, object_path, channel_type, handle_type, handle,
108
 
        suppress_handler):
109
 
      if channel_type == CHANNEL_TYPE_TUBES:
110
 
            self.channel_tubes = Channel(self.conn.dbus_proxy.bus_name,
111
 
                    object_path)
112
 
 
113
 
            self.channel_tubes[CHANNEL_TYPE_TUBES].connect_to_signal (
114
 
                    "TubeStateChanged", self.tube_state_changed_cb)
115
 
            self.channel_tubes[CHANNEL_TYPE_TUBES].connect_to_signal (
116
 
                    "NewTube", self.new_tube_cb)
117
 
            self.channel_tubes[CHANNEL_TYPE_TUBES].connect_to_signal (
118
 
                    "TubeClosed", self.tube_closed_cb)
119
 
 
120
 
            for tube in self.channel_tubes[CHANNEL_TYPE_TUBES].ListTubes():
121
 
                id, initiator, type, service, params, state = (tube[0],
122
 
                        tube[1], tube[2], tube[3], tube[4], tube[5])
123
 
                self.new_tube_cb(id, initiator, type, service, params, state)
124
 
 
125
 
    def new_tube_cb(self, id, initiator, type, service, params, state):
126
 
        initiator_id = self.conn[CONN_INTERFACE].InspectHandles(
127
 
                CONNECTION_HANDLE_TYPE_CONTACT, [initiator])[0]
128
 
 
129
 
        print "new %s tube (%d) offered by %s. Service: %s. State: %s" % (
130
 
                tube_type[type], id, initiator_id, service, tube_state[state])
131
 
 
132
 
        if state == TUBE_STATE_OPEN:
133
 
            self.tube_opened (id)
134
 
 
135
 
    def tube_opened (self, id):
 
99
    def new_channels_cb(self, channels):
 
100
        if self.tube is not None:
 
101
            return
 
102
 
 
103
        for path, props in channels:
 
104
            if props[CHANNEL_INTERFACE + ".ChannelType"] == CHANNEL_TYPE_DBUS_TUBE:
 
105
                self.tube = Channel(self.conn.dbus_proxy.bus_name, path)
 
106
 
 
107
                self.tube[CHANNEL_INTERFACE_TUBE].connect_to_signal(
 
108
                        "TubeChannelStateChanged", self.tube_channel_state_changed_cb)
 
109
                self.tube[CHANNEL_INTERFACE].connect_to_signal(
 
110
                        "Closed", self.tube_closed_cb)
 
111
 
 
112
                self.got_tube(props)
 
113
 
 
114
    def got_tube(self, props):
 
115
        initiator_id = props[CHANNEL_INTERFACE + ".InitiatorID"]
 
116
        service = props[CHANNEL_TYPE_DBUS_TUBE + ".ServiceName"]
 
117
 
 
118
        state = self.tube[PROPERTIES_IFACE].Get(CHANNEL_INTERFACE_TUBE, 'State')
 
119
 
 
120
        print "new D-Bus tube offered by %s. Service: %s. State: %s" % (
 
121
            initiator_id, service, tube_state[state])
 
122
 
 
123
    def tube_opened (self):
136
124
        group_iface = self.channel_text[CHANNEL_INTERFACE_GROUP]
137
125
 
138
 
        tube_conn = TubeConnection(self.conn,
139
 
                self.channel_tubes[CHANNEL_TYPE_TUBES],
140
 
                id, group_iface=group_iface)
141
 
 
142
 
        self.test = Test (tube_conn, self.conn)
143
 
 
144
 
    def tube_state_changed_cb(self, id, state):
145
 
        if state == TUBE_STATE_OPEN:
146
 
            self.tube_opened(id)
147
 
 
148
 
    def tube_closed_cb (self, id):
 
126
        tube_conn = TubeConnection(self.conn, self.tube, self.tube_addr,
 
127
                group_iface=group_iface)
 
128
 
 
129
        self.test = Test(tube_conn, self.conn)
 
130
 
 
131
    def tube_channel_state_changed_cb(self, state):
 
132
        print "tube state changed:", tube_state[state]
 
133
        if state == TUBE_CHANNEL_STATE_OPEN:
 
134
            self.tube_opened()
 
135
 
 
136
    def tube_closed_cb(self):
149
137
        print "tube closed", id
150
138
 
151
139
    def text_channel_members_changed_cb(self, message, added, removed,
161
149
    def __init__(self, account_file, muc_id):
162
150
        Client.__init__(self, account_file, muc_id)
163
151
 
164
 
    def connected_cb(self):
165
 
        Client.connected_cb(self)
 
152
    def ready_cb(self, conn):
 
153
        Client.ready_cb(self, conn)
166
154
 
167
155
        self.join_muc()
168
156
 
169
157
    def muc_joined(self):
170
158
        Client.muc_joined(self)
171
159
 
172
 
        print "muc joined. Offer the tube"
173
 
        self.offer_tube()
174
 
 
175
 
    def tube_opened (self, id):
176
 
        Client.tube_opened(self, id)
 
160
        print "muc joined. Create the tube"
 
161
 
 
162
        self.conn[CONNECTION_INTERFACE_REQUESTS].CreateChannel({
 
163
            CHANNEL_INTERFACE + ".ChannelType": CHANNEL_TYPE_DBUS_TUBE,
 
164
            CHANNEL_INTERFACE + ".TargetHandleType": CONNECTION_HANDLE_TYPE_ROOM,
 
165
            CHANNEL_INTERFACE + ".TargetID": self.muc_id,
 
166
            CHANNEL_TYPE_DBUS_TUBE + ".ServiceName": SERVICE})
 
167
 
 
168
    def got_tube(self, props):
 
169
        Client.got_tube(self, props)
 
170
 
 
171
        params = dbus.Dictionary({"login": "badger", "a_int" : 69},
 
172
                signature='sv')
 
173
 
 
174
        print "Offer tube"
 
175
        self.tube_addr = self.tube[CHANNEL_TYPE_DBUS_TUBE].Offer(params,
 
176
            SOCKET_ACCESS_CONTROL_CREDENTIALS)
 
177
 
 
178
    def tube_opened (self):
 
179
        Client.tube_opened(self)
177
180
 
178
181
        self._emit_test_signal();
179
182
        gobject.timeout_add (20000, self._emit_test_signal)
180
183
 
181
 
    def offer_tube(self):
182
 
        params = {"login": "badger", "a_int" : 69}
183
 
        print "offer tube"
184
 
        id = self.channel_tubes[CHANNEL_TYPE_TUBES].OfferDBusTube(SERVICE,
185
 
                params)
186
 
 
187
184
    def _emit_test_signal (self):
188
185
        print "emit Hello"
189
186
        self.test.Hello()
193
190
    def __init__(self, account_file, muc_id):
194
191
        Client.__init__(self, account_file, muc_id)
195
192
 
196
 
    def connected_cb(self):
197
 
        Client.connected_cb(self)
 
193
    def ready_cb(self, conn):
 
194
        Client.ready_cb(self, conn)
198
195
 
199
196
        self.join_muc()
200
197
 
201
 
    def new_tube_cb(self, id, initiator, type, service, params, state):
202
 
        Client.new_tube_cb(self, id, initiator, type, service, params, state)
203
 
 
204
 
        if state == TUBE_STATE_LOCAL_PENDING and service == SERVICE and\
205
 
                self.test is None:
206
 
            print "accept tube", id
207
 
            self.channel_tubes[CHANNEL_TYPE_TUBES].AcceptDBusTube(id)
208
 
 
209
 
 
210
 
    def tube_opened (self, id):
211
 
        Client.tube_opened(self, id)
 
198
    def got_tube(self, props):
 
199
        Client.got_tube(self, props)
 
200
 
 
201
        print "Accept tube"
 
202
        self.tube_addr = self.tube[CHANNEL_TYPE_DBUS_TUBE].Accept(SOCKET_ACCESS_CONTROL_CREDENTIALS)
 
203
 
 
204
 
 
205
    def tube_opened (self):
 
206
        Client.tube_opened(self)
212
207
 
213
208
        self.test.tube.add_signal_receiver(self.hello_cb, 'Hello', IFACE,
214
209
            path=PATH, sender_keyword='sender')
223
218
        print "Hello from %s" % sender
224
219
 
225
220
        text = "I'm %s and thank you for your hello" % self_id
226
 
        print "call remote Say"
227
221
        self.test.tube.get_object(sender, PATH).Say(text, dbus_interface=IFACE)
228
222
 
229
223
class Test(Object):