jinglesession.h

/*
  Copyright (c) 2007-2023 by Jakob Schröter <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;
 
    enum Action
    {
      ContentAccept,                
      ContentAdd,                   
      ContentModify,                
      ContentReject,                
      ContentRemove,                
      DescriptionInfo,              
      SecurityInfo,                 
      SessionAccept,                
      SessionInfo,                  
      SessionInitiate,              
      SessionTerminate,             
      TransportAccept,              
      TransportInfo,                
      TransportReject,              
      TransportReplace,             
      InvalidAction                 
    };
 
    class GLOOX_API Session : public IqHandler
    {
 
      friend class SessionManager;
 
      public:
        enum State
        {
          Ended,                    
          Pending,                  
          Active                    
        };
 
        class GLOOX_API Reason : public Plugin
        {
          public:
            enum Reasons
            {
              AlternativeSession,           
              Busy,                         
              Cancel,                       
              ConnectivityError,            
              Decline,                      
              Expired,                      
              FailedApplication,            
              FailedTransport,              
              GeneralError,                 
              Gone,                         
              IncompatibleParameters,       
              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 Plugin
            virtual const std::string& filterString() const;
 
            // reimplemented from Plugin
            virtual Tag* tag() const;
 
            // reimplemented from Plugin
            virtual Plugin* newInstance( const Tag* tag ) const { return new Reason( tag ); }
 
            // reimplemented from 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; }
 
            const JID& initiator() const { return m_initiator; }
 
            const JID& responder() const { return m_responder; }
 
            Action action() const { return m_action; }
 
            void addPlugin( const Plugin* plugin ) { if( plugin ) m_plugins.push_back( plugin ); }
 
            const PluginList& plugins() const { return m_plugins; }
 
            Tag* embeddedTag() const { return m_tag; }
 
            // 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 JID& responder,
                    const PluginList& plugins, const std::string& sid );
 
#ifdef JINGLE_TEST
            Jingle( Action action, const JID& initiator, const JID& responder,
                    const Plugin* plugin, const std::string& sid );
            #endif
 
//             /**
//              * Copy constructor.
//              * @param right The instance to copy.
//              */
//             Jingle( const Jingle& right );
 
            Action m_action;
            std::string m_sid;
            JID m_initiator;
            JID m_responder;
            PluginList m_plugins;
            Tag* m_tag;
 
        };
 
        virtual ~Session();
 
        void setInitiator( const JID& initiator ) { m_initiator = initiator; }
 
        const JID& initiator() const { return m_initiator; }
 
        const JID& responder() const { return m_responder; }
 
        void setResponder( const JID& jid ) { m_responder = jid; }
 
        void setHandler( SessionHandler* handler ) { m_handler = handler; }
 
        bool contentAccept( const Content* content );
 
        bool contentAdd( const Content* content );
 
        bool contentAdd( const PluginList& contents );
 
        bool contentModify( const Content* content );
 
        bool contentReject( const Content* content );
 
        bool contentRemove( const Content* content );
 
        bool descriptionInfo( const Plugin* info );
 
        bool securityInfo( const Plugin* info );
 
        bool sessionAccept( const Content* content );
 
        bool sessionAccept( const PluginList& plugins );
 
        bool sessionInfo( const Plugin* info );
 
        bool sessionInitiate( const Content* content );
 
        bool sessionInitiate( const PluginList& plugins );
 
        bool sessionTerminate( Session::Reason* reason );
 
        bool transportAccept( const Content* content );
 
        bool transportInfo( const Plugin* info );
 
        bool transportReject( const Content* content );
 
        bool transportReplace( const Content* content );
 
        State state() const { return m_state; }
 
        void setSID( const std::string& sid ) { m_sid = sid; }
 
        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
        Session( ClientBase* parent, const JID& callee, SessionHandler* jsh );
 
        Session( ClientBase* parent, const JID& callee, const Session::Jingle* jingle,
                 SessionHandler* jsh );
 
        bool doAction( Action action, const Plugin* plugin );
        bool doAction( Action action, const PluginList& plugin );
 
        ClientBase* m_parent;
        State m_state;
        JID m_remote;
        JID m_initiator;
        JID m_responder;
        SessionHandler* m_handler;
        std::string m_sid;
        bool m_valid;
 
    };
 
  }
 
}
 
#endif // JINGLESESSION_H__