adhoc.h

/*
  Copyright (c) 2004-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 ADHOC_H__
#define ADHOC_H__

#include "disconodehandler.h"
#include "discohandler.h"
#include "iqhandler.h"

#include <string>
#include <list>
#include <map>

namespace gloox
{

  class DataForm;
  class ClientBase;
  class Stanza;
  class AdhocHandler;
  class AdhocCommandProvider;

  class GLOOX_API Adhoc : public DiscoNodeHandler, public DiscoHandler, public IqHandler
  {
    public:
      enum AdhocCommandStatus
      {
        AdhocCommandExecuting,      
        AdhocCommandCompleted,      
        AdhocCommandCanceled,       
        AdhocCommandStatusUnknown   
      };

      enum AdhocExecuteActions
      {
        ActionDefault    =  0,      
        ActionPrevious   =  1,      
        ActionNext       =  2,      
        ActionComplete   =  4,      
        ActionCancel     =  8       
      };

      enum AdhocNoteType
      {
        AdhocNoteInfo,              
        AdhocNoteWarn,              
        AdhocNoteError              
      };

      Adhoc( ClientBase *parent );

      virtual ~Adhoc();

      // reimplemented from DiscoNodeHandler
      virtual StringList handleDiscoNodeFeatures( const std::string& node );

      // reimplemented from DiscoNodeHandler
      virtual StringMap handleDiscoNodeIdentities( const std::string& node, std::string& name );

      // reimplemented from DiscoNodeHandler
      virtual DiscoNodeItemList handleDiscoNodeItems( const std::string& node );

      // reimplemented from IqHandler
      virtual bool handleIq( Stanza *stanza );

      // reimplemented from IqHandler
      virtual bool handleIqID( Stanza *stanza, int context );

      // reimplemented from DiscoHandler
      virtual void handleDiscoInfoResult( Stanza *stanza, int context );

      // reimplemented from DiscoHandler
      virtual void handleDiscoItemsResult( Stanza *stanza, int context );

      // reimplemented from DiscoHandler
      virtual void handleDiscoError( Stanza *stanza, int context );

      void registerAdhocCommandProvider( AdhocCommandProvider *acp, const std::string& command,
                                         const std::string& name );

      void checkSupport( const JID& remote, AdhocHandler *ah );

      void getCommands( const JID& remote, AdhocHandler *ah );

      void execute( const JID& remote, const std::string& command, AdhocHandler *ah,
                    const std::string& sessionid = "", DataForm *form = 0,
                    AdhocExecuteActions action = ActionDefault );

      void removeAdhocCommandProvider( const std::string& command );

    private:
      typedef std::map<const std::string, AdhocCommandProvider*> AdhocCommandProviderMap;
      AdhocCommandProviderMap m_adhocCommandProviders;

      enum AdhocContext
      {
        CheckAdhocSupport,
        FetchAdhocCommands,
        ExecuteAdhocCommand
      };

      struct TrackStruct
      {
        JID remote;
        AdhocContext context;
        AdhocHandler *ah;
      };
      typedef std::map<std::string, TrackStruct> AdhocTrackMap;
      AdhocTrackMap m_adhocTrackMap;

      ClientBase *m_parent;

      StringMap m_items;

  };

}

#endif // ADHOC_H__