Conversation.hxx

Go to the documentation of this file.

#if !defined(Conversation_hxx)
#define Conversation_hxx
 
#include "ConversationManager.hxx"
#include "ConversationParticipantAssignment.hxx"
 
namespace recon
{
class Participant;
class LocalParticipant;
class RemoteParticipant;
class RelatedConversationSet;
class BridgeMixer;
 
class Conversation 
{
protected:
   Conversation(ConversationHandle handle, 
                ConversationManager& conversationManager,
                RelatedConversationSet* relatedConversationSet,  // Pass NULL to create new RelatedConversationSet 
                ConversationHandle sharedMediaInterfaceConvHandle,
                ConversationManager::AutoHoldMode autoHoldMode,
                unsigned int maxParticipants = 0);
   virtual void onParticipantAdded(Participant* participant) = 0;
   virtual void onParticipantRemoved(Participant* participant) = 0;
public:
   virtual ~Conversation();
 
   void addParticipant(Participant* participant, unsigned int inputGain = 100, unsigned int outputGain = 100);
   void removeParticipant(Participant* participant);
   void modifyParticipantContribution(Participant* participant, unsigned int inputGain, unsigned int outputGain);
 
   unsigned int getNumLocalParticipants() { return mNumLocalParticipants; }
   unsigned int getNumRemoteParticipants() { return mNumRemoteParticipants; }
   unsigned int getNumRemoteIMParticipants() { return mNumRemoteIMParticipants; }
   unsigned int getNumMediaParticipants() { return mNumMediaParticipants; }
   bool shouldHold();
   bool broadcastOnly();
   void notifyRemoteParticipantsOfHoldChange();
   void relayInstantMessageToRemoteParticipants(ParticipantHandle sourceParticipant, const resip::Data& senderDisplayName, const resip::SipMessage& msg);
 
   void createRelatedConversation(RemoteParticipant* newForkedParticipant, ParticipantHandle origParticipantHandle);
   void join(Conversation* conversation);  // move all non-duplicate participants from this conversation to passed in conversation and destroy this one
 
   void destroy();
 
   ConversationHandle getHandle() { return mHandle; }
   void setMaxParticipants(unsigned int maxParticipants) { mMaxParticipants = maxParticipants; };
   unsigned int getMaxParticipants() const { return mMaxParticipants; };
 
   virtual void confirmParticipant(Participant* participant) {};
 
protected:
   std::shared_ptr<resip::ConfigParse> getConfig() { return mConversationManager.getConfig(); };
 
   friend class Participant;
   friend class SipXParticipant;
   friend class LocalParticipant;
   friend class SipXLocalParticipant;
   friend class RemoteParticipant;
   friend class SipXRemoteParticipant;
   friend class KurentoRemoteParticipant;
   friend class MediaResourceParticipant;
   friend class SipXMediaResourceParticipant;
   void registerParticipant(Participant *, unsigned int inputGain=100, unsigned int outputGain=100);
   void unregisterParticipant(Participant *);
 
   friend class BridgeMixer;
   friend class SipXBridgeMixer;
   friend class KurentoBridgeMixer;
   friend class GstBridgeMixer;
   friend class LibWebRTCBridgeMixer;
   typedef std::map<ParticipantHandle, ConversationParticipantAssignment> ParticipantMap;
   ParticipantMap& getParticipants() { return mParticipants; }  
 
   friend class AddParticipantCmd;
   friend class JoinConversationCmd;
   friend class MoveParticipantCmd;
 
   // sipX Media related members
   // Note: these are only set here if sipXConversationMediaInterfaceMode is used
   friend class ConversationManager;
   friend class SipXMediaStackAdapter;
   friend class KurentoMediaStackAdapter;
   friend class GstMediaStackAdapter;
   friend class LibWebRTCMediaStackAdapter;
   BridgeMixer* getBridgeMixer() noexcept { return mBridgeMixer.get(); }
   std::shared_ptr<BridgeMixer> getBridgeMixerShared() { return mBridgeMixer; }
   virtual void setBridgeMixer(std::shared_ptr<BridgeMixer> mixer) { mBridgeMixer = mixer; }
   virtual bool isSharingMediaInterfaceWithAnotherConversation() { return mSharingMediaInterfaceWithAnotherConversation; }
 
   virtual ConversationManager& getConversationManager() { return mConversationManager; }
 
 
private: 
   ConversationHandle mHandle;
   ConversationManager& mConversationManager;
   RelatedConversationSet *mRelatedConversationSet;
 
   ParticipantMap mParticipants;
   Participant* getParticipant(ParticipantHandle partHandle);
   bool mDestroying;
   unsigned int mNumLocalParticipants;
   unsigned int mNumRemoteParticipants;
   unsigned int mNumRemoteIMParticipants;
   unsigned int mNumMediaParticipants;
   ConversationManager::AutoHoldMode mAutoHoldMode;
   unsigned int mMaxParticipants;
 
   // sipX Media related members
   // Note: these are only set here if sipXConversationMediaInterfaceMode is used
   std::shared_ptr<BridgeMixer> mBridgeMixer;
   bool mSharingMediaInterfaceWithAnotherConversation;
};
 
}
 
#endif
 
 
/* ====================================================================
 
 Copyright (c) 2021, SIP Spectrum, Inc.
 Copyright (c) 2022, Software Freedom Institute https://softwarefreedom.institute
 Copyright (c) 2021, Daniel Pocock https://danielpocock.com
 Copyright (c) 2007-2008, Plantronics, Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are 
 met:
 
 1. Redistributions of source code must retain the above copyright 
    notice, this list of conditions and the following disclaimer. 
 
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution. 
 
 3. Neither the name of Plantronics nor the names of its contributors 
    may be used to endorse or promote products derived from this 
    software without specific prior written permission. 
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ==================================================================== */