Changeset 8558 for branches/jingle

Timestamp:

08/24/07 01:42:31 (16 months ago)

Author:

liori

Message:

Jingle: dialog for accepting voice calls

Location:

branches/jingle

Files:

• data/glade/voip_call_received_dialog.glade (added)
• src/common/farsight/test-jingle.py (modified) (1 diff)
• src/common/jingle.py (modified) (22 diffs)
• src/dialogs.py (modified) (1 diff)
• src/gajim.py (modified) (2 diffs)

branches/jingle/src/common/farsight/test-jingle.py

@@ -53 +53 @@
                 print "WW: stream.signal_native_candidates_prepared()"
                 print "WW: stream.start()"
-                exit()
                 stream.signal_native_candidates_prepared()
                 stream.start()

branches/jingle/src/common/jingle.py

@@ -13 +13 @@
 ''' Handles the jingle signalling protocol. '''
 
+# note: if there will be more types of sessions (possibly file transfer,
+# video...), split this file
+
 import gajim
+import gobject
 import xmpp
 
-# ugly hack
+# ugly hack, fixed in farsight 0.1.24
 import sys, dl, gst
 sys.setdlopenflags(dl.RTLD_NOW | dl.RTLD_GLOBAL)
 import farsight
 sys.setdlopenflags(dl.RTLD_NOW | dl.RTLD_LOCAL)
+
+def timeout_add_and_call(timeout, callable, *args, **kwargs):
+        ''' Call a callback once. If it returns True, add a timeout handler to call it more times.
+        Helper function. '''
+        if callable(*args, **kwargs):
+                return gobject.timeout_add(timeout, callable, *args, **kwargs)
+        return -1       # gobject.source_remove will not object
 
 class JingleStates(object):
@@ -28 +39 @@
         active=2
 
-class Exception(object): pass
-class WrongState(Exception): pass
-class NoCommonCodec(Exception): pass
+class Error(Exception): pass
+class WrongState(Error): pass
+class NoSuchSession(Error): pass
 
 class JingleSession(object):
@@ -55 +66 @@
                 self.sid=sid            # sessionid
 
+                self.accepted=True      # is this session accepted by user
+
                 # callbacks to call on proper contents
                 # use .prepend() to add new callbacks, especially when you're going
@@ -76 +89 @@
                 self.p2psession.connect('error', self.on_p2psession_error)
 
+        ''' Interaction with user '''
+        def approveSession(self):
+                ''' Called when user accepts session in UI (when we aren't the initiator).'''
+                self.accepted=True
+                self.acceptSession()
+
+        def declineSession(self):
+                ''' Called when user declines session in UI (when we aren't the initiator,
+                or when the user wants to stop session completly. '''
+                self.__sessionTerminate()
+
         ''' Middle-level functions to manage contents. Handle local content
         cache and send change notifications. '''
@@ -83 +107 @@
                 The protocol prohibits changing that when pending.
                 Creator must be one of ('we', 'peer', 'initiator', 'responder')'''
+                assert creator in ('we', 'peer', 'initiator', 'responder')
+
                 if self.state==JingleStates.pending:
                         raise WrongState
@@ -105 +131 @@
                 pass
 
+        def acceptSession(self):
+                ''' Check if all contents and user agreed to start session. '''
+                if not self.weinitiate and \
+                    self.accepted and \
+                    all(c.negotiated for c in self.contents.itervalues()):
+                        self.__sessionAccept()
+                else:
         ''' Middle-level function to do stanza exchange. '''
         def startSession(self):
@@ -112 +145 @@
         def sendSessionInfo(self): pass
 
-        ''' Callbacks. '''
+        ''' Session callbacks. '''
         def stanzaCB(self, stanza):
                 ''' A callback for ConnectionJingle. It gets stanza, then
@@ -153 +186 @@
         def __sessionInitiateCB(self, stanza, jingle, error, action):
                 ''' We got a jingle session request from other entity,
-                therefore we are the receiver... Unpack the data. '''
+                therefore we are the receiver... Unpack the data,
+                inform the user. '''
                 self.initiator = jingle['initiator']
                 self.responder = self.ourjid
                 self.peerjid = self.initiator
-
+                self.accepted = False   # user did not accept this session yet
+
+                # TODO: If the initiator is unknown to the receiver (e.g., via presence
+                # subscription) and the receiver has a policy of not communicating via
+                # Jingle with unknown entities, it SHOULD return a <service-unavailable/>
+                # error.
+
+                # Lets check what kind of jingle session does the peer want
                 fail = True
+                contents = []
                 for element in jingle.iterTags('content'):
                         # checking what kind of session this will be
@@ -166 +208 @@
                                 # we've got voip content
                                 self.addContent(element['name'], JingleVoiP(self), 'peer')
+                                contents.append(('VOIP',))
                                 fail = False
 
+                # If there's no content we understand...
                 if fail:
                         # TODO: we should send <unsupported-content/> inside too
+                        # TODO: delete this instance
                         self.connection.connection.send(
                                 xmpp.Error(stanza, xmpp.NS_STANZAS + 'feature-not-implemented'))
@@ -176 +221 @@
 
                 self.state = JingleStates.pending
+
+                # Send event about starting a session
+                self.connection.dispatch('JINGLE_INCOMING', (self.initiator, self.sid, contents))
 
         def __broadcastCB(self, stanza, jingle, error, action):
@@ -199 +247 @@
                 return stanza, jingle
 
-        def __appendContent(self, jingle, content, full=True):
+        def __appendContent(self, jingle, content):
                 ''' Append <content/> element to <jingle/> element,
                 with (full=True) or without (full=False) <content/>
                 children. '''
-                if full:
-                        jingle.addChild(node=content.toXML())
-                else:
-                        jingle.addChild('content',
-                                attrs={'name': content.name, 'creator': content.creator})
-
-        def __appendContents(self, jingle, full=True):
+                jingle.addChild('content',
+                        attrs={'name': content.name, 'creator': content.creator})
+
+        def __appendContents(self, jingle):
                 ''' Append all <content/> elements to <jingle/>.'''
                 # TODO: integrate with __appendContent?
                 # TODO: parameters 'name', 'content'?
                 for content in self.contents.values():
-                        self.__appendContent(jingle, content, full=full)
+                        self.__appendContent(jingle, content)
 
         def __sessionInitiate(self):
@@ -220 +265 @@
                 stanza, jingle = self.__makeJingle('session-initiate')
                 self.__appendContents(jingle)
+                self.__broadcastCB(stanza, jingle, None, 'session-initiate-sent')
                 self.connection.connection.send(stanza)
 
         def __sessionAccept(self):
                 assert self.state==JingleStates.pending
-                stanza, jingle = self.__jingle('session-accept')
-                self.__appendContents(jingle, False)
+                stanza, jingle = self.__makeJingle('session-accept')
+                self.__appendContents(jingle)
+                self.__broadcastCB(stanza, jingle, None, 'session-accept-sent')
                 self.connection.connection.send(stanza)
                 self.state=JingleStates.active
@@ -231 +278 @@
         def __sessionInfo(self, payload=None):
                 assert self.state!=JingleStates.ended
-                stanza, jingle = self.__jingle('session-info')
+                stanza, jingle = self.__makeJingle('session-info')
                 if payload:
                         jingle.addChild(node=payload)
@@ -238 +285 @@
         def __sessionTerminate(self):
                 assert self.state!=JingleStates.ended
-                stanza, jingle = self.__jingle('session-terminate')
+                stanza, jingle = self.__makeJingle('session-terminate')
                 self.connection.connection.send(stanza)
+                self.__broadcastCB(stanza, jingle, None, 'session-terminate-sent')
 
         def __contentAdd(self):
@@ -252 +300 @@
         def __contentRemove(self):
                 assert self.state!=JingleStates.ended
+
+        def sendContentAccept(self, content):
+                assert self.state!=JingleStates.ended
+                stanza, jingle = self.__makeJingle('content-accept')
+                jingle.addChild(node=content)
+                self.connection.connection.send(stanza)
 
         def sendTransportInfo(self, content):
@@ -271 +325 @@
                 #self.creator = None
                 #self.name = None
+                self.negotiated = False         # is this content already negotiated?
 
 class JingleVoiP(JingleContent):
@@ -289 +344 @@
                 ''' Called when something related to our content was sent by peer. '''
                 callbacks = {
+                        # these are called when *we* get stanzas
                         'content-accept': [self.__getRemoteCodecsCB],
                         'content-add': [],
                         'content-modify': [],
                         'content-remove': [],
-                        'session-accept': [self.__getRemoteCodecsCB],
+                        'session-accept': [self.__getRemoteCodecsCB, self.__startMic],
                         'session-info': [],
                         'session-initiate': [self.__getRemoteCodecsCB],
-                        'session-terminate': [],
+                        'session-terminate': [self.__stop],
                         'transport-info': [self.__transportInfoCB],
                         'iq-result': [],
                         'iq-error': [],
+                        # these are called when *we* sent these stanzas
+                        'session-initiate-sent': [self.__sessionInitiateSentCB],
+                        'session-accept-sent': [self.__startMic],
+                        'session-terminate-sent': [self.__stop],
                 }[action]
                 for callback in callbacks:
                         callback(stanza, content, error, action)
 
+        def __sessionInitiateSentCB(self, stanza, content, error, action):
+                ''' Add our things to session-initiate stanza. '''
+                content.setAttr('profile', 'RTP/AVP')
+                content.addChild(xmpp.NS_JINGLE_AUDIO+' description', payload=self.iterCodecs())
+                content.addChild(xmpp.NS_JINGLE_ICE_UDP+' transport')
+
         def __getRemoteCodecsCB(self, stanza, content, error, action):
+                ''' Get peer codecs from what we get from peer. '''
                 if self.got_codecs: return
 
@@ -363 +430 @@
                         payload=payload)
 
-        def setupStream(self):
-                self.p2pstream = self.session.p2psession.create_stream(
-                        farsight.MEDIA_TYPE_AUDIO, farsight.STREAM_DIRECTION_BOTH)
-                self.p2pstream.set_property('transmitter', 'libjingle')
-                self.p2pstream.connect('error', self.on_p2pstream_error)
-                self.p2pstream.connect('new-active-candidate-pair', self.on_p2pstream_new_active_candidate_pair)
-                self.p2pstream.connect('codec-changed', self.on_p2pstream_codec_changed)
-                self.p2pstream.connect('native-candidates-prepared', self.on_p2pstream_native_candidates_prepared)
-                self.p2pstream.connect('state-changed', self.on_p2pstream_state_changed)
-                self.p2pstream.connect('new-native-candidate', self.on_p2pstream_new_native_candidate)
-
-                self.p2pstream.set_remote_codecs(self.p2pstream.get_local_codecs())
-
-                self.p2pstream.prepare_transports()
-
-                self.p2pstream.set_active_codec(8)      #???
-
-                sink = gst.element_factory_make('alsasink')
-                sink.set_property('sync', False)
-                sink.set_property('latency-time', 20000)
-                sink.set_property('buffer-time', 80000)
-
-                src = gst.element_factory_make('audiotestsrc')
-                src.set_property('blocksize', 320)
-                #src.set_property('latency-time', 20000)
-                src.set_property('is-live', True)
-
-                self.p2pstream.set_sink(sink)
-                self.p2pstream.set_source(src)
-
         def on_p2pstream_error(self, *whatever): pass
         def on_p2pstream_new_active_candidate_pair(self, stream, native, remote): pass
         def on_p2pstream_codec_changed(self, stream, codecid): pass
         def on_p2pstream_native_candidates_prepared(self, *whatever):
-                for candidate in self.p2pstream.get_native_candidate_list():
-                        self.send_candidate(candidate)
+                pass
+
         def on_p2pstream_state_changed(self, stream, state, dir):
                 if state==farsight.STREAM_STATE_CONNECTED:
                         stream.signal_native_candidates_prepared()
                         stream.start()
+                        self.pipeline.set_state(gst.STATE_PLAYING)
+
+                        self.negotiated = True
+                        if not self.session.weinitiate:
+                                self.session.sendContentAccept(self.__content((xmpp.Node('description', payload=self.iterCodecs()),)))
+                        self.session.acceptSession()
+
         def on_p2pstream_new_native_candidate(self, p2pstream, candidate_id):
                 candidates = p2pstream.get_native_candidate(candidate_id)
@@ -408 +452 @@
                 for candidate in candidates:
                         self.send_candidate(candidate)
+
         def send_candidate(self, candidate):
                 attrs={
@@ -443 +488 @@
                         yield xmpp.Node('payload-type', a, p)
 
+        ''' Things to control the gstreamer's pipeline '''
+        def setupStream(self):
+                # the pipeline
+                self.pipeline = gst.Pipeline()
+
+                # the network part
+                self.p2pstream = self.session.p2psession.create_stream(
+                        farsight.MEDIA_TYPE_AUDIO, farsight.STREAM_DIRECTION_BOTH)
+                self.p2pstream.set_pipeline(self.pipeline)
+                self.p2pstream.set_property('transmitter', 'libjingle')
+                self.p2pstream.connect('error', self.on_p2pstream_error)
+                self.p2pstream.connect('new-active-candidate-pair', self.on_p2pstream_new_active_candidate_pair)
+                self.p2pstream.connect('codec-changed', self.on_p2pstream_codec_changed)
+                self.p2pstream.connect('native-candidates-prepared', self.on_p2pstream_native_candidates_prepared)
+                self.p2pstream.connect('state-changed', self.on_p2pstream_state_changed)
+                self.p2pstream.connect('new-native-candidate', self.on_p2pstream_new_native_candidate)
+
+                self.p2pstream.set_remote_codecs(self.p2pstream.get_local_codecs())
+
+                self.p2pstream.prepare_transports()
+
+                self.p2pstream.set_active_codec(8)      #???
+
+                # the local parts
+                # TODO: use gconfaudiosink?
+                sink = gst.element_factory_make('alsasink')
+                sink.set_property('sync', False)
+                sink.set_property('latency-time', 20000)
+                sink.set_property('buffer-time', 80000)
+                self.pipeline.add(sink)
+
+                self.src_signal = gst.element_factory_make('audiotestsrc')
+                self.src_signal.set_property('blocksize', 320)
+                self.src_signal.set_property('freq', 440)
+                self.pipeline.add(self.src_signal)
+
+                # TODO: use gconfaudiosrc?
+                self.src_mic = gst.element_factory_make('alsasrc')
+                self.src_mic.set_property('blocksize', 320)
+                self.pipeline.add(self.src_mic)
+
+                self.mic_volume = gst.element_factory_make('volume')
+                self.mic_volume.set_property('volume', 0)
+                self.pipeline.add(self.mic_volume)
+
+                self.adder = gst.element_factory_make('adder')
+                self.pipeline.add(self.adder)
+
+                # link gst elements
+                self.src_signal.link(self.adder)
+                self.src_mic.link(self.mic_volume)
+                self.mic_volume.link(self.adder)
+
+                # this will actually start before the pipeline will be started.
+                # no worries, though; it's only a ringing sound
+                def signal():
+                        while True:
+                                self.src_signal.set_property('volume', 0.5)
+                                yield True # wait 750 ms
+                                yield True # wait 750 ms
+                                self.src_signal.set_property('volume', 0)
+                                yield True # wait 750 ms
+                self.signal_cb_id = timeout_add_and_call(750, signal().__iter__().next)
+
+                self.p2pstream.set_sink(sink)
+                self.p2pstream.set_source(self.adder)
+
+        def __startMic(self, *things):
+                gobject.source_remove(self.signal_cb_id)
+                self.src_signal.set_property('volume', 0)
+                self.mic_volume.set_property('volume', 1)
+
+        def __stop(self, *things):
+                self.pipeline.set_state(gst.STATE_NULL)
+                gobject.source_remove(self.signal_cb_id)
+
+        def __del__(self):
+                self.__stop()
+
 class ConnectionJingle(object):
         ''' This object depends on that it is a part of Connection class. '''
@@ -485 +609 @@
                 # do we need to create a new jingle object
                 if (jid, sid) not in self.__sessions:
-                        # TODO: we should check its type here...
                         newjingle = JingleSession(con=self, weinitiate=False, jid=jid, sid=sid)
                         self.addJingle(newjingle)
@@ -502 +625 @@
                 jingle.addContent('voice', JingleVoiP(jingle))
                 jingle.startSession()
+        def getJingleSession(self, jid, sid):
+                try:
+                        return self.__sessions[(jid, sid)]
+                except KeyError:
+                        raise NoSuchSession

branches/jingle/src/dialogs.py

@@ -3299 +3299 @@
         def on_close_window(self, widget):
                 self.window.destroy()
+
+class VoIPCallReceivedDialog(object):
+        def __init__(self, account, contact_jid, sid):
+                self.account = account
+                self.jid = contact_jid
+                self.sid = sid
+
+                xml = gtkgui_helpers.get_glade('voip_call_received_dialog.glade')
+                xml.signal_autoconnect(self)
+                
+                contact = gajim.contacts.get_first_contact_from_jid(account, contact_jid)
+                if contact and contact.name:
+                        contact_text = '%s (%s)' % (contact.name, contact_jid)
+                else:
+                        contact_text = contact_jid
+
+                # do the substitution
+                dialog = xml.get_widget('voip_call_received_messagedialog')
+                dialog.set_property('secondary-text',
+                        dialog.get_property('secondary-text') % {'contact': contact_text})
+
+                dialog.show_all()
+
+        def on_voip_call_received_messagedialog_close(self, dialog):
+                return self.on_voip_call_received_messagedialog_response(dialog, gtk.RESPONSE_NO)
+        def on_voip_call_received_messagedialog_response(self, dialog, response):
+                # we've got response from user, either stop connecting or accept the call
+                session = gajim.connections[self.account].getJingleSession(self.jid, self.sid)
+                if response==gtk.RESPONSE_YES:
+                        session.approveSession()
+                else: # response==gtk.RESPONSE_NO
+                        session.declineSession()
+
+                dialog.destroy()

branches/jingle/src/gajim.py

@@ -1865 +1865 @@
                         is_modal = False, ok_handler = on_ok)
 
+        def handle_event_jingle_incoming(self, account, data):
+                # ('JINGLE_INCOMING', account, peer jid, sid, tuple-of-contents==(type, data...))
+                # TODO: conditional blocking if peer is not in roster
+                
+                # unpack data
+                peerjid, sid, contents = data
+                content_types = set(c[0] for c in contents)
+
+                # check type of jingle session
+                if 'VOIP' in content_types:
+                        # a voip session...
+                        # we now handle only voip, so the only thing we will do here is
+                        # not to return from function
+                        pass
+                else:
+                        # unknown session type... it should be declined in common/jingle.py
+                        return
+
+                if helpers.allow_popup_window(account):
+                        dialogs.VoIPCallReceivedDialog(account, peerjid, sid)
+
+                # TODO: not checked
+                self.add_event(account, peerjid, 'jingle-session', (sid, contents))
+
+                if helpers.allow_showing_notification(account):
+                        # TODO: we should use another pixmap ;-)
+                        img = os.path.join(gajim.DATA_DIR, 'pixmaps', 'events',
+                                'ft_request.png')
+                        txt = _('%s wants to start a jingle session.') % gajim.get_name_from_jid(
+                                account, jid)
+                        path = gtkgui_helpers.get_path_to_generic_or_avatar(img)
+                        event_type = _('Jingle Session Request')
+                        notify.popup(event_type, jid, account, 'jingle-request',
+                                path_to_image = path, title = event_type, text = txt)
+
         def read_sleepy(self):
                 '''Check idle status and change that status if needed'''
@@ -2193 +2228 @@
                         'SEARCH_RESULT': self.handle_event_search_result,
                         'RESOURCE_CONFLICT': self.handle_event_resource_conflict,
+                        'JINGLE_INCOMING': self.handle_event_jingle_incoming,
                 }
                 gajim.handlers = self.handlers