jinglesession.h

/*
  Copyright (c) 2007-2009 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 "jingleplugin.h"

#include <string>

namespace gloox
{

  class ClientBase;

  namespace Jingle
  {

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

    typedef std::list<const Plugin*> PluginList;

    enum Action
    {
      ContentAccept,                
      ContentAdd,                   
      ContentModify,                
      ContentReject,                
      ContentRemove,                
      DescriptionInfo,              
      SessionAccept,                
      SessionInfo,                  
      SessionInitiate,              
      SessionTerminate,             
      TransportAccept,              
      TransportInfo,                
      TransportReject,              
      TransportReplace,             
      InvalidAction                 
    };

    class GLOOX_API Session : public IqHandler
    {

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

        class GLOOX_API Reason : public Plugin
        {
          public:
            enum Reasons
            {
              AlternativeSession,   
              Busy,                 
              Cancel,               
              ConnectivityError,    
              Decline,              
              Expired,              
              GeneralError,         
              Gone,                 
              MediaError,           
              SecurityError,        
              Success,              
              Timeout,              
              UnsupportedApplications,
              UnsupportedTransports,
              InvalidReason         
            };

            Reason( Reasons reason, const std::string& sid = EmptyString,
                    const std::string& text = EmptyString );

            Reason( const Tag* tag = 0 );

            virtual ~Reason() {}

            Reasons reason() const { return m_reason; }

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

            const std::string& text() const { return m_text; }

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

            // reimplemented from Jingle::Plugin
            virtual Tag* tag() const;

            // reimplemented from Jingle::Plugin
            virtual Plugin* clone() const;

          private:
            Reasons m_reason;
            std::string m_sid;
            std::string m_text;

        };

        class Jingle : public StanzaExtension
        {

          friend class Session;

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

            virtual ~Jingle();

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

            void setInitiator( const JID& jid ) { m_initiator = jid; }

            const JID& initiator() const { return m_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;

            // reimplemented from StanzaExtension
            virtual StanzaExtension* clone() const;

#ifdef JINGLE_TEST
          public:
#else
          private:
#endif

            Jingle( Action action, const JID& initiator,
                    const PluginList& plugins, const std::string& sid );

            Jingle( Action action, const JID& initiator,
                    const Plugin* plugin, const std::string& sid );

            Jingle( const Jingle& right );

            Action m_action;
            std::string m_sid;
            JID m_initiator;
            JID m_responder;
            PluginList m_plugins;

        };

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

        Session( ClientBase* parent, const Session::Jingle* jingle,
                 SessionHandler* jsh );

        virtual ~Session();

        bool initiate( const PluginList& plugins );

        bool accept( const Content* content );

        bool inform( Action action, const Plugin* plugin );

        bool terminate( Reason* reason );

        State state() const { return m_state; }

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

        // 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;
        JID m_initiator;
        SessionHandler* m_handler;
        std::string m_sid;
        bool m_valid;

    };

  }

}

#endif // JINGLESESSION_H__