im.h

Go to the documentation of this file.

/*
 * im.h
 *
 * Instant Messaging classes
 *
 * 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_IM_H
#define OPAL_IM_IM_H

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

#if OPAL_HAS_IM

#include <ptclib/url.h>
#include <opal//transports.h>


class OpalCall;
class OpalMediaFormat;
class OpalIMEndPoint;



#if OPAL_HAS_SIPIM
  #define OPAL_SIPIM             "SIP-IM"
  #define OpalSIPIM              GetOpalSIPIM()
  extern const OpalMediaFormat & GetOpalSIPIM();
#endif

#if OPAL_HAS_RFC4103
  #define OPAL_T140              "T.140"
  #define OpalT140               GetOpalT140()
  extern const OpalMediaFormat & GetOpalT140();
#endif

#if OPAL_HAS_MSRP
  #define OPAL_MSRP              "MSRP"
  #define OpalMSRP               GetOpalMSRP()
  extern const OpalMediaFormat & GetOpalMSRP();
#endif

#define OPAL_IM_MEDIA_TYPE_PREFIX "im-"



class OpalIM : public PObject
{
    PCLASSINFO_WITH_CLONE(OpalIM, PObject);
  public:
    OpalIM();

    PString m_conversationId;         

    PURL                  m_to;       
    OpalTransportAddress  m_toAddr;   
    PURL                  m_from;     
    OpalTransportAddress  m_fromAddr; 
    PString               m_fromName; 
    PStringToString       m_bodies;   
    PMultiPartList        m_bodyParts;

    typedef uint32_t MessageID;
    MessageID m_messageId;            
    static MessageID GetNextMessageId();
};



class OpalIMContext : public PSafeObject
{
  PCLASSINFO(OpalIMContext, PSafeObject);

  protected:
    OpalIMContext();

  public:
    ~OpalIMContext();

    struct ConversationInfo
    {
      ConversationInfo(
        const PString & id,
        bool opening,
        bool byRemote,
        const PSafePtr<OpalIMContext> & context
      ) : m_conversationId(id)
        , m_opening(opening)
        , m_byRemote(byRemote)
        , m_context(context)
      { }

      PString                 m_conversationId; 
      bool                    m_opening;        
      bool                    m_byRemote;       
      PSafePtr<OpalIMContext> m_context;        
    };

    virtual bool Open(
      bool byRemote   
    );

    virtual void Close();


    P_DECLARE_STREAMABLE_ENUM(MessageDisposition,
      DispositionPending,     
      DispositionAccepted,    
      DeliveryOK,             
      DisplayConfirmed,       
      ProcessedNotification,  
      StorageNotification,    

      DispositionErrors,
      GenericError,           
      UnacceptableContent,    
      InvalidContent,         
      DestinationUnknown,     
      DestinationUnavailable, 
      TransmissionTimeout,    
      TransportFailure,       
      ConversationClosed,     
      UnsupportedFeature,     
      DeliveryFailed          
    );

    virtual MessageDisposition Send(
      OpalIM * message    
    );

    struct DispositionInfo {
      PString            m_conversationId; 
      OpalIM::MessageID  m_messageId;      
      MessageDisposition m_disposition;    
    };

    virtual void OnMessageDisposition(
      const DispositionInfo & info    
    );

    typedef PNotifierTemplate<DispositionInfo> MessageDispositionNotifier;

    #define PDECLARE_MessageDispositionNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::DispositionInfo)

    #define PDECLARE_ASYNC_MessageDispositionNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::DispositionInfo)

    #define PCREATE_MessageDispositionNotifier(fn) PCREATE_NOTIFIER2(fn, OpalIMContext::DispositionInfo)

    void SetMessageDispositionNotifier(
      const MessageDispositionNotifier & notifier   
    );


    virtual MessageDisposition OnMessageReceived(
      const OpalIM & message    
    );

    typedef PNotifierTemplate<OpalIM> MessageReceivedNotifier;

    #define PDECLARE_MessageReceivedNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalIMContext, cls, fn, OpalIM)

    #define PDECLARE_ASYNC_MessageReceivedNotifier(cls, fn) PDECLARE_ASYNC_NOTIFIER2(OpalIMContext, cls, fn, OpalIM)

    #define PCREATE_MessageReceivedNotifier(fn) PCREATE_NOTIFIER2(fn, OpalIM)

    void SetMessageReceivedNotifier(
      const MessageReceivedNotifier & notifier   
    );


    static const PCaselessString & CompositionIndicationActive();  
    static const PCaselessString & CompositionIndicationIdle();    

    struct CompositionInfo
    {
      PString m_conversationId; 
      PString m_state;          
      PString m_contentType;    

      CompositionInfo(
        const PString & id,
        const PString & state,
        const PString & contentType = PString::Empty()
      ) : m_conversationId(id)
        , m_state(state)
        , m_contentType(contentType)
      { }
    };

    virtual bool SendCompositionIndication(
      const CompositionInfo & info  
    );

    virtual void OnCompositionIndication(
      const CompositionInfo & info     
    );

    typedef PNotifierTemplate<CompositionInfo> CompositionIndicationNotifier;

    #define PDECLARE_CompositionIndicationNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::CompositionInfo)

    #define PDECLARE_ASYNC_CompositionIndicationNotifier(cls, fn) PDECLARE_ASYNC_NOTIFIER2(OpalIMContext, cls, fn, OpalIMContext::CompositionInfo)

    #define PCREATE_CompositionIndicationNotifier(fn) PCREATE_NOTIFIER2(fn, OpalIMContext::CompositionInfo)

    void SetCompositionIndicationNotifier(
      const CompositionIndicationNotifier & notifier   
    );


    virtual bool CheckContentType(
      const PString & contentType   
    ) const;

    virtual PStringArray GetContentTypes() const;

    static PString CreateKey(const PURL & from, const PURL & to);


    const PString & GetID() const          { return m_conversationId; }

    const PString & GetKey() const         { return m_key; }

    const PURL & GetRemoteURL() const      { return m_remoteURL; }

    const PString & GetRemoteName() const  { return m_remoteName; }

    const PURL & GetLocalURL() const       { return m_localURL; }

    const PString & GetLocalName() const    { return m_localName; }

    void SetLocalName(const PString & name) { m_localName = name; }

    PStringOptions & GetAttributes() { return m_attributes; }
    const PStringOptions & GetAttributes() const { return m_attributes; }

  protected:
    void ResetLastUsed();

    virtual MessageDisposition InternalSend();
    virtual MessageDisposition InternalSendOutsideCall(OpalIM & message);
    virtual MessageDisposition InternalSendInsideCall(OpalIM & message);
    virtual void InternalOnMessageSent(const DispositionInfo & info);

    OpalIMEndPoint * m_endpoint;
    PStringOptions   m_attributes;

    PSafePtr<OpalCall> m_call;
    bool               m_weStartedCall;

    PDECLARE_MUTEX(               m_notificationMutex);
    MessageDispositionNotifier    m_messageDispositionNotifier;
    MessageReceivedNotifier       m_messageReceivedNotifier;
    CompositionIndicationNotifier m_compositionIndicationNotifier;

    PDECLARE_MUTEX(m_outgoingMessagesMutex);
    OpalIM       * m_currentOutgoingMessage;
    PQueue<OpalIM> m_outgoingMessages;

    PDECLARE_MUTEX(m_lastUsedMutex);
    PTime  m_lastUsed;

    PString m_conversationId;
    PURL    m_localURL;
    PString m_localName;
    PURL    m_remoteURL;
    PString m_remoteName;
    PString m_key;

  friend class OpalIMEndPoint;
  friend class OpalIMConnection;
};


#endif // OPAL_HAS_IM

#endif // OPAL_IM_IM_H