Changeset 8467 for branches/jingle

Timestamp:

08/07/07 18:34:09 (16 months ago)

Author:

liori

Message:

Jingle: fixes for content-description negotiation.

Location:

branches/jingle/src

Files:

• chat_control.py (modified) (1 diff)
• common/jingle.py (modified) (16 diffs)

branches/jingle/src/chat_control.py

@@ -1193 +1193 @@
 
         def _on_start_voip_menuitem_activate(self, *things):
-                print 'Start VoiP'
-                gajim.connections[self.account].startVoiP(self.contact.jid)
+                gajim.connections[self.account].startVoiP(self.contact.jid+'/'+self.contact.resource)
 
         def _update_gpg(self):

branches/jingle/src/common/jingle.py

@@ -31 +31 @@
         ''' This represents one jingle session. '''
         __metaclass__=meta.VerboseClassType
-        def __init__(self, con, weinitiate, jid):
+        def __init__(self, con, weinitiate, jid, sid=None):
                 ''' con -- connection object,
                     weinitiate -- boolean, are we the initiator?
@@ -48 +48 @@
                 # what state is session in? (one from JingleStates)
                 self.state=JingleStates.ended
-                self.sid=con.connection.getAnID()       # sessionid
+                if not sid:
+                        sid=con.connection.getAnID()
+                self.sid=sid            # sessionid
 
                 # callbacks to call on proper contents
-                # use .prepend() to add new callbacks
-                self.callbacks=dict((key, [self.__defaultCB]) for key in
-                        ('content-add', 'content-modify',
-                         'content-remove', 'session-accept', 'session-info',
-                         'session-initiate', 'session-terminate',
-                         'transport-info'))
-                self.callbacks['iq-result']=[]
-                self.callbacks['iq-error']=[]
-
-                self.callbacks['content-accept']=[self.__contentAcceptCB, self.__defaultCB]
+                # use .prepend() to add new callbacks, especially when you're going
+                # to send error instead of ack
+                self.callbacks={
+                        'content-accept':       [self.__contentAcceptCB, self.__defaultCB],
+                        'content-add':          [self.__defaultCB],
+                        'content-modify':       [self.__defaultCB],
+                        'content-remove':       [self.__defaultCB],
+                        'session-accept':       [self.__contentAcceptCB, self.__defaultCB],
+                        'session-info':         [self.__defaultCB],
+                        'session-initiate':     [self.__sessionInitiateCB, self.__defaultCB],
+                        'session-terminate':    [self.__defaultCB],
+                        'transport-info':       [self.__defaultCB],
+                        'iq-result':            [],
+                        'iq-error':             [],
+                }
 
         ''' Middle-level functions to manage contents. Handle local content
@@ -94 +101 @@
         def startSession(self):
                 ''' Start session. '''
-                self.__sessionInitiate(self)
+                self.__sessionInitiate()
 
         def sendSessionInfo(self): pass
@@ -129 +136 @@
                 and stop processing. '''
                 response = stanza.buildReply('result')
-                self.connection.send(response)
-                raise xmpp.NodeProcessed
+                self.connection.connection.send(response)
 
         def __contentAcceptCB(self, stanza, jingle, error):
@@ -141 +147 @@
                         
 
+        def sessionInitiateCB(self, stanza):
+                ''' We got a jingle session request from other entity,
+                therefore we are the receiver... Unpack the data. '''
+                jingle = stanza.getTag('jingle')
+                self.initiator = jingle['initiator']
+                self.responder = self.ourjid
+                self.jid = self.initiator
+
+                fail = True
+                for element in jingle.iterTags('content'):
+                        # checking what kind of session this will be
+                        desc_ns = element.getTag('description').getNamespace()
+                        tran_ns = element.getTag('transport').getNamespace()
+                        if desc_ns==xmpp.NS_JINGLE_AUDIO and tran_ns==xmpp.NS_JINGLE_ICE_UDP:
+                                # we've got voip content
+                                self.addContent(element['name'], JingleVoiP(self, node=element), 'peer')
+                                fail = False
+
+                if fail:
+                        # TODO: we should send <unsupported-content/> inside too
+                        self.connection.connection.send(
+                                xmpp.Error(stanza, xmpp.NS_STANZAS + 'feature-not-implemented'))
+                        self.connection.deleteJingle(self)
+                        raise xmpp.NodeProcessed
+
+                self.state = JingleStates.pending
+
         ''' Methods that make/send proper pieces of XML. They check if the session
         is in appropriate state. '''
         def __makeJingle(self, action):
-                stanza = xmpp.Iq(typ='set', to=xmpp.JID(self.jid))
+                stanza = xmpp.Iq(typ='set', to=xmpp.JID(self.peerjid))
                 jingle = stanza.addChild('jingle', attrs={
                         'xmlns': 'http://www.xmpp.org/extensions/xep-0166.html#ns',
@@ -162 +195 @@
                         jingle.addChild('content',
                                 attrs={'name': content.name, 'creator': content.creator})
-                return c
 
         def __appendContents(self, jingle, full=True):
@@ -175 +207 @@
                 stanza, jingle = self.__makeJingle('session-initiate')
                 self.__appendContents(jingle)
-                self.connection.send(jingle)
+                self.connection.connection.send(stanza)
 
         def __sessionAccept(self):
@@ -181 +213 @@
                 stanza, jingle = self.__jingle('session-accept')
                 self.__appendContents(jingle, False)
-                self.connection.send(stanza)
+                self.connection.connection.send(stanza)
                 self.state=JingleStates.active
 
@@ -189 +221 @@
                 if payload:
                         jingle.addChild(node=payload)
-                self.connection.send(stanza)
+                self.connection.connection.send(stanza)
 
         def __sessionTerminate(self):
                 assert self.state!=JingleStates.ended
                 stanza, jingle = self.__jingle('session-terminate')
-                self.connection.send(stanza)
+                self.connection.connection.send(stanza)
 
         def __contentAdd(self):
@@ -212 +244 @@
 
         '''Callbacks'''
-        def sessionInitiateCB(self, stanza):
-                ''' We got a jingle session request from other entity,
-                therefore we are the receiver... Unpack the data. '''
-                jingle = stanza.getTag('jingle')
-                self.initiator = jingle['initiator']
-                self.responder = self.ourjid
-                self.jid = self.initiator
-                self.state = JingleStates.pending
-                self.sid = jingle['sid']
-                for element in jingle.iterTags('content'):
-                        content={'creator': 'initiator',
-                                'name': element['name'],
-                                'description': element.getTag('description'),
-                                'transport': element.getTag('transport')}
-                        if element.has_attr('profile'):
-                                content['profile']=element['profile']
-                        self.contents[('initiator', content['name'])]=content
-
         def sessionTerminateCB(self, stanza): pass
+
+class Codec(object):
+        ''' This class keeps description of a single codec. '''
+        def __init__(self, name, id=None, **params):
+                ''' Create new codec description. '''
+                self.name = name
+                self.id = id
+                self.attrs = {'name': self.name, 'id': self.id, 'channels': 1}
+                for key in ('channels', 'clockrate', 'maxptime', 'ptime'):
+                        if key in params:
+                                self.attrs[key]=params[key]
+                                del params[key]
+                self.params = params
+
+        def __eq__(a, b):
+                ''' Compare two codec descriptions. '''
+                # TODO: check out what should be tested...
+                if a.name!=b.name: return False
+                # ...
+                return True
+
+        def toXML(self):
+                return xmpp.Node('payload',
+                        attrs=self.attrs,
+                        payload=(xmpp.Node('parameter', {'name': k, 'value': v}) for k,v in self.params))
 
 class JingleAudioSession(object):
         __metaclass__=meta.VerboseClassType
-        class Codec(object):
-                ''' This class keeps description of a single codec. '''
-                def __init__(self, name, id=None, **params):
-                        ''' Create new codec description. '''
-                        self.name = name
-                        self.id = id
-                        self.attrs = {'name': self.name, 'id': self.id, 'channels': 1}
-                        for key in ('channels', 'clockrate', 'maxptime', 'ptime'):
-                                if key in params:
-                                        self.attrs[key]=params[key]
-                                del params[key]
-                        self.params = params
-
-                def __eq__(a, b):
-                        ''' Compare two codec descriptions. '''
-                        # TODO: check out what should be tested...
-                        if a.name!=b.name: return False
-                        # ...
-                        return True
-
-                def toXML(self):
-                        return xmpp.Node('payload',
-                                attrs=self.attrs,
-                                payload=(xmpp.Node('parameter', {'name': k, 'value': v}) for k,v in self.params))
-
-        def __init__(self, content):
+        def __init__(self, content, fromNode):
                 self.content = content
 
                 self.initiator_codecs=[]
                 self.responder_codecs=[]
+
+                if fromNode:
+                        # read all codecs peer understand
+                        for payload in fromNode.iterTags('payload-type'):
+                                attrs = fromNode.getAttrs().copy()
+                                for param in fromNode.iterTags('parameter'):
+                                        attrs[param['name']]=param['value']
+                                self.initiator_codecs.append(Codec(**attrs))
 
         def sessionInitiateCB(self, stanza, ourcontent):
@@ -285 +307 @@
                 out = []
                 ids = range(128)
-                for codec in other:
+                for codec in other_l:
                         if codec in our_l:
                                 out.append(codec)
@@ -305 +327 @@
         def __codecsList(self, codecs):
                 ''' Prepares a description element with codecs given as a parameter. '''
-                return xmpp.Node('description',
-                        xmlns=xmpp.NS_JINGLE_AUDIO,
+                return xmpp.Node(xmpp.NS_JINGLE_AUDIO+' description',
                         payload=(codec.toXML() for codec in codecs))
 
@@ -330 +351 @@
         def toXML(self):
                 ''' ICE-UDP doesn't send much in its transport stanza... '''
-                return xmpp.Node('transport', xmlns=xmpp.JINGLE_ICE_UDP)
+                return xmpp.Node(xmpp.NS_JINGLE_ICE_UDP+' transport')
 
 class JingleVoiP(object):
@@ -336 +357 @@
         over an ICE UDP protocol. '''
         __metaclass__=meta.VerboseClassType
-        def __init__(self):
-                self.audio = JingleAudioSession(self)
+        def __init__(self, session, node=None):
+                self.session = session
+
+                if node is None:
+                        self.audio = JingleAudioSession(self)
+                else:
+                        self.audio = JingleAudioSession(self, node.getTag('content'))
                 self.transport = JingleICEUDPSession(self)
 
@@ -344 +370 @@
                 return xmpp.Node('content',
                         attrs={'name': self.name, 'creator': self.creator, 'profile': 'RTP/AVP'},
-                        childs=[self.audio.toXML(), self.transport.toXML()])
-
-        def _sessionInitiateCB(self):
-                ''' Called when we initiate the session. '''
-                self.transport._sessionInitiateCB()
+                        payload=[self.audio.toXML(), self.transport.toXML()])
 
 class ConnectionJingle(object):
@@ -392 +414 @@
                 # do we need to create a new jingle object
                 if (jid, sid) not in self.__sessions:
-                        # we should check its type here...
-                        newjingle = JingleAudioSession(con=self, weinitiate=False, jid=jid)
+                        # TODO: we should check its type here...
+                        newjingle = JingleSession(con=self, weinitiate=False, jid=jid, sid=sid)
                         self.addJingle(newjingle)
 
                 # we already have such session in dispatcher...
-                return self.__sessions[(jid, sid)].stanzaCB(stanza)
+                self.__sessions[(jid, sid)].stanzaCB(stanza)
+
+                raise xmpp.NodeProcessed
 
         def addJingleIqCallback(self, jid, id, jingle):