Swiften/Client/CoreClient.h

/*
 * Copyright (c) 2010-2012 Remko Tronçon
 * Licensed under the GNU General Public License v3.
 * See Documentation/Licenses/GPLv3.txt for more information.
 */

#pragma once

#include <string>
#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>
#include <Swiften/Base/boost_bsignals.h>
#include <Swiften/Entity/Entity.h>
#include <Swiften/JID/JID.h>
#include <Swiften/Client/ClientError.h>
#include <Swiften/Client/ClientOptions.h>
#include <Swiften/Base/SafeByteArray.h>
#include <Swiften/TLS/CertificateWithKey.h>

namespace Swift {
  class ChainedConnector;
  class Message;
  class Presence;
  class Error;
  class IQRouter;
  class TLSContextFactory;
  class ConnectionFactory;
  class Connection;
  class TimerFactory;
  class ClientSession;
  class StanzaChannel;
  class Stanza;
  class SessionStream;
  class CertificateTrustChecker;
  class NetworkFactories;
  class ClientSessionStanzaChannel;

  class SWIFTEN_API CoreClient : public Entity {
    public: 
      CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories);
      ~CoreClient();

      void setCertificate(CertificateWithKey::ref certificate);

      void connect(const ClientOptions& = ClientOptions());

      void disconnect();

      void sendMessage(boost::shared_ptr<Message>);

      void sendPresence(boost::shared_ptr<Presence>);

      void sendData(const std::string& data);

      IQRouter* getIQRouter() const {
        return iqRouter_;
      }

      bool isAvailable() const;

      bool isActive() const;

      const JID& getJID() const;

      bool getStreamManagementEnabled() const;

      bool isStreamEncrypted() const;

      StanzaChannel* getStanzaChannel() const;

      void setCertificateTrustChecker(CertificateTrustChecker*);

    public:
      boost::signal<void (const boost::optional<ClientError>&)> onDisconnected;

      boost::signal<void ()> onConnected;

      boost::signal<void (const SafeByteArray&)> onDataRead;

      boost::signal<void (const SafeByteArray&)> onDataWritten;

      boost::signal<void (boost::shared_ptr<Message>)> onMessageReceived;

      boost::signal<void (boost::shared_ptr<Presence>) > onPresenceReceived;

      boost::signal<void (boost::shared_ptr<Stanza>)> onStanzaAcked;

    protected:
      boost::shared_ptr<ClientSession> getSession() const {
        return session_;
      }

      NetworkFactories* getNetworkFactories() const {
        return networkFactories;
      }

      virtual void handleConnected() {};

    private:
      void handleConnectorFinished(boost::shared_ptr<Connection>, boost::shared_ptr<Error> error);
      void handleStanzaChannelAvailableChanged(bool available);
      void handleSessionFinished(boost::shared_ptr<Error>);
      void handleNeedCredentials();
      void handleDataRead(const SafeByteArray&);
      void handleDataWritten(const SafeByteArray&);
      void handlePresenceReceived(boost::shared_ptr<Presence>);
      void handleMessageReceived(boost::shared_ptr<Message>);
      void handleStanzaAcked(boost::shared_ptr<Stanza>);
      void purgePassword();
      void bindSessionToStream();

      void resetConnector();
      void resetSession();
      void forceReset();

    private:
      JID jid_;
      SafeByteArray password_;
      NetworkFactories* networkFactories;
      ClientSessionStanzaChannel* stanzaChannel_;
      IQRouter* iqRouter_;
      ClientOptions options;
      boost::shared_ptr<ChainedConnector> connector_;
      std::vector<ConnectionFactory*> proxyConnectionFactories;
      boost::shared_ptr<Connection> connection_;
      boost::shared_ptr<SessionStream> sessionStream_;
      boost::shared_ptr<ClientSession> session_;
      CertificateWithKey::ref certificate_;
      bool disconnectRequested_;
      CertificateTrustChecker* certificateTrustChecker;
  };
}