lyncep.h

Go to the documentation of this file.

/*
 * lyncep.h
 *
 * Header file for Lync (UCMA) interface
 *
 * Copyright (C) 2016 Vox Lucida Pty. Ltd.
 *
 * 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 Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 */

#ifndef OPAL_EP_LYNCEP_H
#define OPAL_EP_LYNCEP_H

#include <opal_config.h>

#if OPAL_LYNC

#include <string>

/* Class to hide Lync UCMA Managed code
   This odd arrangement is so when compiling the shim and we include this header
   file, we do not get all the PTLib stuff which interferes with the managed
   code interfacing.
 */
class OpalLyncShim
{
  public:
    OpalLyncShim();
    ~OpalLyncShim();

    struct Platform;
    struct PlatformParams {
      std::string m_localHost;
      unsigned    m_localPort;
      std::string m_GRUU;
      std::string m_certificateFriendlyName;
      PlatformParams() : m_localPort(5061) { }
    };
    Platform * CreatePlatform(const char * userAgent, const PlatformParams & params);
    Platform * CreatePlatform(const char * userAgent, const char * provisioningID);
    Platform * CreatePlatform(const char * userAgent);
    bool DestroyPlatform(Platform * & platform);

    struct ApplicationEndpoint;
    struct ApplicationParams {
      std::string m_ownerURI;
      std::string m_proxyHost;
      unsigned    m_proxyPort;
      bool        m_defaultRoutingEndpoint;
      bool        m_publicisePresence;
      ApplicationParams() : m_proxyPort(0), m_defaultRoutingEndpoint(false), m_publicisePresence(true) { }
    };
    ApplicationEndpoint * CreateApplicationEndpoint(Platform & platform, const ApplicationParams & params);
    void DestroyApplicationEndpoint(ApplicationEndpoint * & app);

    struct UserEndpoint;
    UserEndpoint * CreateUserEndpoint(Platform & platform,
                                      const char * uri,
                                      const char * password,
                                      const char * authID,
                                      const char * domain);
    void DestroyUserEndpoint(UserEndpoint * & user);

    struct Conversation;
    Conversation * CreateConversation(ApplicationEndpoint & aep, const char * uri, const char * phone, const char * display);
    Conversation * CreateConversation(UserEndpoint & uep);
    void DestroyConversation(Conversation * & conv);

    struct AudioVideoCall;
    AudioVideoCall * CreateAudioVideoCall(Conversation & conv, const char * uri);
    bool AcceptAudioVideoCall(AudioVideoCall & call);
    bool ForwardAudioVideoCall(AudioVideoCall & call, const char * targetURI);
    bool TransferAudioVideoCall(AudioVideoCall & call, const char * targetURI);
    bool TransferAudioVideoCall(AudioVideoCall & call, AudioVideoCall & target, int delayMillis);
    void DestroyAudioVideoCall(AudioVideoCall * & call);

    struct AudioVideoFlow;
    AudioVideoFlow * CreateAudioVideoFlow(AudioVideoCall & call);
    void DestroyAudioVideoFlow(AudioVideoFlow * & flow);

    struct SpeechRecognitionConnector;
    SpeechRecognitionConnector * CreateSpeechRecognitionConnector(AudioVideoFlow & flow);
    void DestroySpeechRecognitionConnector(SpeechRecognitionConnector * & connector);

    struct ToneController;
    ToneController * CreateToneController(AudioVideoFlow & flow);
    bool SendTone(ToneController & toneController, int toneId);
    void DestroyToneController(ToneController * & toneController);

    struct SpeechSynthesisConnector;
    SpeechSynthesisConnector * CreateSpeechSynthesisConnector(AudioVideoFlow & flow);
    void DestroySpeechSynthesisConnector(SpeechSynthesisConnector * & connector);

    struct AudioVideoStream;
    AudioVideoStream * CreateAudioVideoStream(SpeechRecognitionConnector & connector);
    AudioVideoStream * CreateAudioVideoStream(SpeechSynthesisConnector & connector);
    int ReadAudioVideoStream(AudioVideoStream & stream, unsigned char * data, int size);
    int WriteAudioVideoStream(AudioVideoStream & stream, const unsigned char * data, int length);
    void DestroyAudioVideoStream(SpeechRecognitionConnector & connector, AudioVideoStream * & stream);
    void DestroyAudioVideoStream(SpeechSynthesisConnector & connector, AudioVideoStream * & stream);

    static int const CallStateEstablishing;
    static int const CallStateEstablished;
    static int const CallStateTerminating;
#if PTRACING
    static std::string GetCallStateName(int callState);
    static std::string GetTransferStateName(int transferState);
    static std::string GetToneIdName(int toneId);
#endif

    static int const MediaFlowActive;
#if PTRACING
    static std::string GetMediaFlowName(int mediaFlow);
#endif

    struct IncomingLyncCallInfo {
      AudioVideoCall * m_call;
      const char     * m_remoteUri;
      const char     * m_displayName;
      const char     * m_destinationUri;
      const char     * m_transferredBy;
    };
    virtual void OnIncomingLyncCall(const IncomingLyncCallInfo & /*info*/) { }
    virtual void OnLyncCallStateChanged(int /*previousState*/, int /*newState*/) { }
    virtual void OnLyncCallEstablished() { }
    virtual void OnLyncCallFailed(const std::string & /*error*/) { }
    virtual void OnLyncCallTransferReceived(const std::string & /*TransferDestination*/, const std::string & /*TransferredBy*/) { }
    virtual void OnLyncCallTransferStateChanged(int /*previousState*/, int /*newState*/) { }
    virtual void OnLyncCallToneReceived(int /*toneId*/, float /* volume */) { }
    virtual void OnLyncCallIncomingFaxDetected() { }
    virtual void OnMediaFlowStateChanged(int /*previousState*/, int /*newState*/) { }
    virtual bool OnApplicationProvisioning(ApplicationEndpoint * aep);

    const std::string & GetLastError() const { return m_lastError; }

  protected:
#if PTRACING
    virtual void OnTraceOutput(unsigned level, const char * file, unsigned line, const char * out) = 0;
#endif

  private:
    struct Notifications;
    Notifications * m_allocatedNotifications;
    Notifications & m_notifications;
    std::string m_lastError;
};


#ifndef OPAL_LYNC_SHIM

#include <opal/endpoint.h>
#include <opal/connection.h>



class OpalLyncConnection;

#if PTRACING
  class OpalLyncShimBase : public OpalLyncShim
  {
    protected:
      virtual void OnTraceOutput(unsigned level, const char * file, unsigned line, const char * out) override;
  };
#else
  typedef OpalLyncShim OpalLyncShimBase;
#endif


class OpalLyncEndPoint : public OpalEndPoint, public OpalLyncShimBase
{
    PCLASSINFO(OpalLyncEndPoint, OpalEndPoint);
  public:
    OpalLyncEndPoint(
      OpalManager & manager,
      const char *prefix = "lync"
    );

    virtual ~OpalLyncEndPoint();

    virtual void ShutDown();

    virtual OpalMediaFormatList GetMediaFormats() const;

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

    virtual PBoolean GarbageCollection();

    bool Register(
      const PString & provisioningID
    );

    bool RegisterApplication(
      const PlatformParams & platformParams,
      const ApplicationParams & appParams
    );

    ApplicationEndpoint * GetRegisteredApplication() const { return m_applicationRegistration; }

    struct UserParams
    {
      PString m_uri;
      PString m_authID;
      PString m_password;
      PString m_domain;
    };

    PString RegisterUser(
      const UserParams & info
    );

    bool UnregisterUser(
      const PString & uri
    );

    UserEndpoint * GetRegisteredUser(
      const PString & uri
    ) const;

    PStringArray GetRegisteredUsers() const;

    virtual OpalLyncConnection * CreateConnection(
      OpalCall & call,     
      void * userData,     
      unsigned int options,
      OpalConnection::StringOptions * stringOptions
    );

    void AdjustLyncURI(PString & uri);

    const PTimeInterval & GetTransferDelay() const { return m_transferDelay; }

  protected:
    virtual bool OnApplicationProvisioning(ApplicationEndpoint * aep);
    virtual void OnIncomingLyncCall(const IncomingLyncCallInfo & info) override;

    Platform * m_platform;
    ApplicationEndpoint * m_applicationRegistration;

    typedef std::map<PString, UserEndpoint *> RegistrationMap;
    RegistrationMap m_registrations;
    PDECLARE_MUTEX( m_registrationMutex);

    PTimeInterval m_transferDelay;
};


class OpalLyncConnection : public OpalConnection, public OpalLyncShimBase
{
    PCLASSINFO(OpalLyncConnection, OpalConnection);
  public:
    OpalLyncConnection(
      OpalCall & call,
      OpalLyncEndPoint & ep,
      void * userData,
      unsigned options,
      OpalConnection::StringOptions * stringOptions
    );

    virtual bool IsNetworkConnection() const { return true; }

    virtual PBoolean SetUpConnection();

    virtual void OnReleased();

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual PBoolean SetAlerting(
      const PString & calleeName,   
      PBoolean withMedia                
    );

    virtual PBoolean SetConnected();

    virtual PBoolean ForwardCall(
      const PString & forwardParty   
    );

    virtual bool TransferConnection(
      const PString & remoteParty   
    );

    virtual PBoolean SendUserInputTone(
      char tone,              
      unsigned duration = 0   
    );

    virtual OpalMediaStream * CreateMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource                        
    );

    void SetUpIncomingLyncCall(const IncomingLyncCallInfo & info);

  protected:
    OpalLyncEndPoint & m_endpoint;

    Conversation   * m_conversation;
    AudioVideoCall * m_audioVideoCall;
    AudioVideoFlow * m_flow;
    ToneController * m_toneController;
    bool             m_mediaActive;

    virtual void OnLyncCallStateChanged(int previousState, int newState) override;
    virtual void OnLyncCallEstablished() override;
    virtual void OnLyncCallFailed(const std::string & error) override;
    virtual void OnLyncCallTransferReceived(const std::string & transferDestination, const std::string & tansferredBy) override;
    virtual void OnLyncCallTransferStateChanged(int previousState, int newState) override;
    virtual void OnLyncCallToneReceived(int toneId, float volume) override;
    virtual void OnLyncCallIncomingFaxDetected() override;
    virtual void OnMediaFlowStateChanged(int previousState, int newState) override;

    PString InternalConvertLyncURI(const PString & uri) const;

  friend class OpalLyncMediaStream;
};


class OpalLyncMediaStream : public OpalMediaStream, public OpalLyncShimBase
{
    PCLASSINFO(OpalLyncMediaStream, OpalMediaStream);
  public:
    OpalLyncMediaStream(
      OpalLyncConnection & conn,           
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource                        
    );

    ~OpalLyncMediaStream();


    virtual PBoolean Open();

    virtual bool IsEstablished() const;

    virtual PBoolean ReadData(
      BYTE * data,      
      PINDEX size,      
      PINDEX & length   
    );

    virtual PBoolean WriteData(
      const BYTE * data,   
      PINDEX length,       
      PINDEX & written     
    );

    virtual PBoolean IsSynchronous() const;

  protected:
    virtual void InternalClose();

    OpalLyncConnection         & m_connection;
    SpeechRecognitionConnector * m_inputConnector;
    SpeechSynthesisConnector   * m_outputConnector;
    AudioVideoStream           * m_avStream;
    PBYTEArray                   m_silence;
    bool                         m_closing;
};


#endif // OPAL_LYNC_INTERNAL

#endif // OPAL_LYNC

#endif // OPAL_EP_LYNCEP_H


// End of File ///////////////////////////////////////////////////////////////