jinglesession.h

/*
  Copyright (c) 2007-2008 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/


#ifndef JINGLESESSION_H__
#define JINGLESESSION_H__

#include "stanzaextension.h"
#include "tag.h"
#include "iqhandler.h"

#include <string>

namespace gloox
{

  class ClientBase;

  namespace Jingle
  {

    class Description;
    class Transport;
    class SessionHandler;
    class Content;

    typedef std::list<const Content*> ContentList;

    enum Action
    {
      ContentAccept,                
      ContentAdd,                   
      ContentModify,                
      ContentRemove,                
      ContentReplace,               
      SessionAccept,                
      SessionInfo,                  
      SessionInitiate,              
      SessionTerminate,             
      TransportInfo,                
      InvalidAction                 
    };

    class GLOOX_API Session : public IqHandler
    {

      public:
        enum State
        {
          Ended,                    
          Pending,                  
          Active                    
        };

        class Jingle : public StanzaExtension
        {

          friend class Session;

          public:
            Jingle( const Tag* tag = 0 );

            virtual ~Jingle();

            void addContent( const Content* content, Action action );

            const std::string& sid() const { return m_sid; }

            void setInitiator( const std::string& initiator ) { m_initiator = initiator; }

            void setResponder( const std::string& responder ) { m_responder = responder; }

            Action action() const { return m_action; }

            // reimplemented from StanzaExtension
            virtual const std::string& filterString() const;

            // reimplemented from StanzaExtension
            virtual StanzaExtension* newInstance( const Tag* tag ) const
            {
              return new Jingle( tag );
            }

            // reimplemented from StanzaExtension
            virtual Tag* tag() const;

#ifdef JINGLE_TEST
          public:
#else
          private:
#endif

            Jingle( Action action, const ContentList& contents, const std::string& sid );

            Jingle( Action action, const Content* content, const std::string& sid );

            Action m_action;
            std::string m_sid;
            std::string m_initiator;
            std::string m_responder;
            ContentList m_contents;

        };

        Session( ClientBase* parent, const JID& callee, SessionHandler* jsh );

        virtual ~Session();

        bool initiate();

        bool terminate();

        State state() const { return m_state; }

        void addContent( Content* content )
        {
          if( content )
            m_contents.push_back( content );
        }

        // reimplemented from IqHandler
        virtual bool handleIq( const IQ& iq );

        // reimplemented from IqHandler
        virtual void handleIqID( const IQ& iq, int context );

#ifdef JINGLE_TEST
      public:
#else
      private:
#endif
        ClientBase* m_parent;
        State m_state;
        JID m_callee;
        SessionHandler* m_handler;
        ContentList m_contents;
        std::string m_sid;
        bool m_valid;

    };

  }

}

#endif // JINGLESESSION_H__

---