im_ep.h

Go to the documentation of this file.

/*
 * im_ep.h
 *
 * Endpoint for Instant Messaging
 *
 * Open Phone Abstraction Library (OPAL)
 *
 * Copyright (c) 2008 Post Increment
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): ______________________________________.
 */

#ifndef OPAL_IM_EP_H
#define OPAL_IM_EP_H

#include <ptlib.h>
#include <opal_config.h>

#if OPAL_HAS_IM

#include <opal/endpoint.h>


class OpalIMEndPoint : public OpalEndPoint
{
  public:
    static const PCaselessString & Prefix();

    OpalIMEndPoint(OpalManager & manager);
    ~OpalIMEndPoint();


    virtual PSafePtr<OpalConnection> MakeConnection(
      OpalCall & call,          
      const PString & party,    
      void * userData = NULL,          
      unsigned int options = 0,     
      OpalConnection::StringOptions * stringOptions = NULL 
    );

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual PBoolean GarbageCollection();

    virtual void ShutDown();


    PSafePtr<OpalIMContext> CreateContext(
      const PURL & localURL,      
      const PURL & remoteURL,     
      const char * scheme = NULL  
    ) { return InternalCreateContext(localURL, remoteURL, scheme, false, NULL, NULL); }

    PSafePtr<OpalIMContext> CreateContext(
      OpalCall & call
    );

    void RemoveContext(OpalIMContext * context, bool byRemote);

    PSafePtr<OpalIMContext> FindContextByIdWithLock(
      const PString & key,
      PSafetyMode mode = PSafeReadWrite
    );

    PSafePtr<OpalIMContext> FindContextByNamesWithLock(
      const PURL & local, 
      const PURL & remote, 
      PSafetyMode mode = PSafeReadWrite
    );

    PSafePtr<OpalIMContext> FindContextForMessageWithLock(
      OpalIM & im,
      OpalConnection * conn = NULL
    );


    virtual void OnConversation(
      const OpalIMContext::ConversationInfo & info
    );

    typedef PNotifierTemplate<OpalIMContext::ConversationInfo> ConversationNotifier;

    #define PDECLARE_ConversationNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::ConversationInfo)

    #define PDECLARE_ASYNC_ConversationNotifier(cls, fn) PDECLARE_ASYNC_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::ConversationInfo)

    #define PCREATE_ConversationNotifier(fn) PCREATE_NOTIFIER2(fn, OpalIMContext::ConversationInfo)

    void AddNotifier(
      const ConversationNotifier & notifier,  
      const PString & scheme                  
    );

    bool RemoveNotifier(const ConversationNotifier & notifier, const PString & scheme);


    OpalIMContext::MessageDisposition OnRawMessageReceived(
      OpalIM & message,
      OpalConnection * connnection,
      PString & errorInfo
    );

    OpalManager & GetManager() const { return m_manager; }

  protected:
    PSafePtr<OpalIMContext> InternalCreateContext(
      const PURL & localURL,
      const PURL & remoteURL,
      const char * scheme,
      bool byRemote,
      OpalCall * call,
      const char * conversationID
    );

    OpalManager & m_manager;
    typedef PSafeDictionary<PString, OpalIMContext> ContextsByConversationId;
    ContextsByConversationId m_contextsByConversationId;

    PDECLARE_MUTEX(m_contextsByNamesMutex);
    typedef std::multimap<PString, PString> ContextsByNames;
    ContextsByNames m_contextsByNames;

    PDECLARE_MUTEX(m_notifierMutex);
    typedef std::multimap<PString, ConversationNotifier> ConversationMap;
    ConversationMap m_notifiers;

    PTime m_lastGarbageCollection;
    bool m_deleting;
};


class OpalIMConnection : public OpalConnection
{
    PCLASSINFO(OpalIMConnection, OpalConnection);
  public:
    OpalIMConnection(
      OpalCall & call,              
      OpalIMEndPoint & endpoint,    
      void * userData,              
      unsigned options,             
      OpalConnection::StringOptions * stringOptions 
    );

    virtual PBoolean IsNetworkConnection() const { return false; }

    virtual PBoolean OnSetUpConnection();

    virtual void OnEstablished();

    virtual void OnReleased();

  protected:
    OpalIMContext * m_context;
};


#endif // OPAL_HAS_IM

#endif // OPAL_IM_EP_H