Changeset 8461 for branches/jingle/src/common/jingle.py

Timestamp:

08/07/07 01:19:57 (17 months ago)

Author:

liori

Message:

Jingle: UI entry point and lots of small changes.

Files:

• branches/jingle/src/common/jingle.py (modified) (15 diffs)

branches/jingle/src/common/jingle.py

@@ -13 +13 @@
 ''' Handles the jingle signalling protocol. '''
 
+import gajim
 import xmpp
+
+import meta
 
 class JingleStates(object):
@@ -21 +24 @@
         active=2
 
-class WrongState(exception): pass
-class NoCommonCodec(exception): pass
+class Exception(object): pass
+class WrongState(Exception): pass
+class NoCommonCodec(Exception): pass
 
 class JingleSession(object):
         ''' This represents one jingle session. '''
+        __metaclass__=meta.VerboseClassType
         def __init__(self, con, weinitiate, jid):
                 ''' con -- connection object,
@@ -33 +38 @@
                 self.connection=con     # connection to use
                 # our full jid
-                self.ourjid=gajim.get_full_jid_from_account(self.connection.name)
-                self.jid=jid            # jid we connect to
+                self.ourjid=gajim.get_jid_from_account(self.connection.name)+'/'+con.server_resource
+                self.peerjid=jid        # jid we connect to
                 # jid we use as the initiator
-                self.initiator=weinitiate and self.ourjid or self.jid
+                self.initiator=weinitiate and self.ourjid or self.peerjid
                 # jid we use as the responder
-                self.responder=weinitiate and self.jid or self.ourjid
+                self.responder=weinitiate and self.peerjid or self.ourjid
                 # are we an initiator?
                 self.weinitiate=weinitiate
                 # what state is session in? (one from JingleStates)
                 self.state=JingleStates.ended
-                self.sid=con.getAnID()  # sessionid
+                self.sid=con.connection.getAnID()       # sessionid
 
                 # callbacks to call on proper contents
                 # use .prepend() to add new callbacks
                 self.callbacks=dict((key, [self.__defaultCB]) for key in
-                        ('content-accept', 'content-add', 'content-modify',
+                        ('content-add', 'content-modify',
                          'content-remove', 'session-accept', 'session-info',
                          'session-initiate', 'session-terminate',
@@ -55 +60 @@
                 self.callbacks['iq-error']=[]
 
+                self.callbacks['content-accept']=[self.__contentAcceptCB, self.__defaultCB]
+
         ''' Middle-level functions to manage contents. Handle local content
         cache and send change notifications. '''
-        def addContent(self, name, description, transport, profile=None):
+        def addContent(self, name, content, initiator='we'):
                 ''' Add new content to session. If the session is active,
                 this will send proper stanza to update session. 
-                The protocol prohibits changing that when pending.'''
+                The protocol prohibits changing that when pending.
+                Initiator must be one of ('we', 'peer', 'initiator', 'responder')'''
                 if self.state==JingleStates.pending:
                         raise WrongState
 
-                content={'creator': 'initiator',
-                        'name': name,
-                        'description': description,
-                        'transport': transport}
-                if profile is not None:
-                        content['profile']=profile
-                self.contents[('initiator', name)]=content
+                if (initiator=='we' and self.weinitiate) or (initiator=='peer' and not self.weinitiate):
+                        initiator='initiator'
+                elif (initiator=='peer' and self.weinitiate) or (initiator=='we' and not self.weinitiate):
+                        initiator='responder'
+                content.creator = initiator
+                content.name = name
+                self.contents[(initiator,name)]=content
 
                 if self.state==JingleStates.active:
                         pass # TODO: send proper stanza, shouldn't be needed now
+
+        def removeContent(self, creator, name):
+                ''' We do not need this now '''
+                pass
+
+        def modifyContent(self, creator, name, *someother):
+                ''' We do not need this now '''
+                pass
 
         ''' Middle-level function to do stanza exchange. '''
@@ -93 +109 @@
                         # it's an iq-error stanza
                         callables = 'iq-error'
-                else if jingle:
+                elif jingle:
                         # it's a jingle action
                         action = jingle.getAttr('action')
@@ -116 +132 @@
                 raise xmpp.NodeProcessed
 
+        def __contentAcceptCB(self, stanza, jingle, error):
+                ''' Called when we get content-accept stanza or equivalent one
+                (like session-accept).'''
+                # check which contents are accepted, call their callbacks
+                for content in jingle.iterTags('content'):
+                        creator = content['creator']
+                        name = content['name']
+                        
+
         ''' Methods that make/send proper pieces of XML. They check if the session
         is in appropriate state. '''
-        def makeJingle(self, action):
+        def __makeJingle(self, action):
                 stanza = xmpp.Iq(typ='set', to=xmpp.JID(self.jid))
-                jingle = stanza.addChild('jingle', attrs=
+                jingle = stanza.addChild('jingle', attrs={
                         'xmlns': 'http://www.xmpp.org/extensions/xep-0166.html#ns',
                         'action': action,
@@ -128 +153 @@
                 return stanza, jingle
 
-        def appendContent(self, jingle, content, full=True):
+        def __appendContent(self, jingle, content, full=True):
                 ''' Append <content/> element to <jingle/> element,
                 with (full=True) or without (full=False) <content/>
                 children. '''
-                c=jingle.addChild('content', attrs={
-                        'creator': content['creator'],
-                        'name': content['name']})
-                if 'profile' in content:
-                        c['profile']=content['profile']
                 if full:
-                        c.addChild(node=content['description'])
-                        c.addChild(node=content['transport'])
+                        jingle.addChild(node=content.toXML())
+                else:
+                        jingle.addChild('content',
+                                attrs={'name': content.name, 'creator': content.creator})
                 return c
 
-        def appendContents(self, jingle, full=True):
+        def __appendContents(self, jingle, full=True):
                 ''' Append all <content/> elements to <jingle/>.'''
                 # TODO: integrate with __appendContent?
@@ -151 +173 @@
         def __sessionInitiate(self):
                 assert self.state==JingleStates.ended
+                stanza, jingle = self.__makeJingle('session-initiate')
+                self.__appendContents(jingle)
+                self.connection.send(jingle)
 
         def __sessionAccept(self):
@@ -198 +223 @@
                 for element in jingle.iterTags('content'):
                         content={'creator': 'initiator',
-                                'name': element['name']
+                                'name': element['name'],
                                 'description': element.getTag('description'),
                                 'transport': element.getTag('transport')}
@@ -208 +233 @@
 
 class JingleAudioSession(object):
+        __metaclass__=meta.VerboseClassType
         class Codec(object):
                 ''' This class keeps description of a single codec. '''
@@ -233 +259 @@
                                 payload=(xmpp.Node('parameter', {'name': k, 'value': v}) for k,v in self.params))
 
-        def __init__(self, con, weinitiate, jid):
-                JingleSession.__init__(self, con, weinitiate, jid)
-                if weinitiate:
-                        pass #add voice content
-                self.callbacks['session-initiate'].prepend(
+        def __init__(self, content):
+                self.content = content
 
                 self.initiator_codecs=[]
                 self.responder_codecs=[]
+
+        def sessionInitiateCB(self, stanza, ourcontent):
+                pass
 
         ''' "Negotiation" of codecs... simply presenting what *we* can do, nothing more... '''
@@ -283 +309 @@
                         payload=(codec.toXML() for codec in codecs))
 
+        def toXML(self):
+                if not self.initiator_codecs:
+                        # we are the initiator, so just send our codecs
+                        self.initiator_codecs = self.getOurCodecs()
+                        return self.__codecsList(self.initiator_codecs)
+                else:
+                        # we are the responder, we SHOULD adjust our codec list
+                        self.responder_codecs = self.getOurCodecs(self.initiator_codecs)
+                        return self.__codecsList(self.responder_codecs)
+
 class JingleICEUDPSession(object):
-        def __init__(self, con, weinitiate, jid):
+        __metaclass__=meta.VerboseClassType
+        def __init__(self, content):
+                self.content = content
+
+        def _sessionInitiateCB(self):
+                ''' Called when we initiate the session. '''
                 pass
 
-class JingleVoiP(JingleSession):
+        def toXML(self):
+                ''' ICE-UDP doesn't send much in its transport stanza... '''
+                return xmpp.Node('transport', xmlns=xmpp.JINGLE_ICE_UDP)
+
+class JingleVoiP(object):
         ''' Jingle VoiP sessions consist of audio content transported
         over an ICE UDP protocol. '''
-        def __init__(*data):
-                JingleAudioSession.__init__(*data)
-                JingleICEUDPSession.__init__(*data)
+        __metaclass__=meta.VerboseClassType
+        def __init__(self):
+                self.audio = JingleAudioSession(self)
+                self.transport = JingleICEUDPSession(self)
+
+        def toXML(self):
+                ''' Return proper XML for <content/> element. '''
+                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()
 
 class ConnectionJingle(object):
@@ -308 +364 @@
                 jingle - a JingleSession object.
                 '''
-                self.__sessions[(jingle.jid, jingle.sid)]=jingle
+                self.__sessions[(jingle.peerjid, jingle.sid)]=jingle
 
         def deleteJingle(self, jingle):
                 ''' Remove a jingle session from a jingle stanza dispatcher '''
-                del self.__session[(jingle.jid, jingle.sid)]
-
-        def _jingleCB(self, con, stanza):
+                del self.__session[(jingle.peerjid, jingle.sid)]
+
+        def _JingleCB(self, con, stanza):
                 ''' The jingle stanza dispatcher.
                 Route jingle stanza to proper JingleSession object,
@@ -331 +387 @@
 
                 jingle = stanza.getTag('jingle')
+                if not jingle: return
                 sid = jingle.getAttr('sid')
 
@@ -342 +399 @@
                 return self.__sessions[(jid, sid)].stanzaCB(stanza)
 
-        def addJingleIqCallback(jid, id, jingle):
+        def addJingleIqCallback(self, jid, id, jingle):
                 self.__iq_responses[(jid, id)]=jingle
+
+        def startVoiP(self, jid):
+                jingle = JingleSession(self, weinitiate=True, jid=jid)
+                self.addJingle(jingle)
+                jingle.addContent('voice', JingleVoiP())
+                jingle.startSession()