Skip to content
Snippets Groups Projects
Select Git revision
  • 562c9e02184499125a00bbff2f1497be88a66c1e
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/releaseWindowsTestOne
  • release/windowsReleaseTest
  • release/releaseTest
  • release/releaseWindowsTest
  • release/201910
  • release/qt/201910
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • 4.0.0
  • 2.2.0
  • 2.1.0
  • 2.0.1
  • 2.0.0
  • 1.4.1
  • 1.4.0
  • 1.3.0
  • 1.2.0
  • 1.1.0
31 results

voiplink.h

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    voiplink.h 8.31 KiB
    /*
     *  Copyright (C) 2005-2007 Savoir-Faire Linux inc.
     *  Author: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
     *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
     *  Author : Laurielle Lea <laurielle.lea@savoirfairelinux.com>
     *
     *  This program is free software; you can redistribute it and/or modify
     *  it under the terms of the GNU General Public License as published by
     *  the Free Software Foundation; either version 2 of the License, or
     *  (at your option) any later version.
     *
     *  This program is distributed in the hope that it will be useful,
     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *  GNU General Public License for more details.
     *
     *  You should have received a copy of the GNU General Public License
     *  along with this program; if not, write to the Free Software
     *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     */
    
    #ifndef __VOIP_LINK_H__
    #define __VOIP_LINK_H__
    
    #include <string>
    #include "call.h"
    #include <map>
    #include <cc++/thread.h> // for mutex
    
    class AudioCodec;
    
    struct pjsip_rx_data;
    
    /** Define AccountID type */
    typedef std::string AccountID;
    
    /** Define a map that associate a Call object to a call identifier */
    typedef std::map<CallID, Call*> CallMap;
    
    /**
     * @file voiplink.h
     * @brief Listener and manager interface for each VoIP protocol
     */
    class VoIPLink {
      public:
    
        /**
         * Constructor
         * @param accountID The account identifier
         */
        VoIPLink(const AccountID& accountID);
    
        /**
         * Virtual destructor
         */
        virtual ~VoIPLink (void);
    
        /** Contains all the state an Voip can be in */
        enum RegistrationState {Unregistered, Trying, Registered, Error, ErrorAuth , ErrorNetwork , ErrorHost};
    
        /**
         * Virtual method
         * Event listener. Each event send by the call manager is received and handled from here
         */
        virtual void getEvent (void) = 0;
    
        /** 
         * Virtual method
         * Try to initiate the pjsip engine/thread and set config 
         * @return bool True if OK
         */
        virtual bool init (void) = 0;
        
        /**
         * Virtual method
         * Check if a local IP can be found
         * @return bool True if network is reachable
         */
        virtual bool checkNetwork (void) = 0;
        
        /**
         * Virtual method
         * Delete link-related stuuf like calls
         */
        virtual void terminate (void) = 0;
        
        /**
         * Virtual method
         * Build and send SIP registration request
         * @return bool True on success
         *		  false otherwise
         */
        virtual int sendRegister (void) = 0;
        
        /**
         * Virtual method
         * Build and send SIP unregistration request
         * @return bool True on success
         *		  false otherwise
         */
        virtual int sendUnregister (void) = 0;
    
        /**
         * Place a new call
         * @param id  The call identifier
         * @param toUrl  The Sip address of the recipient of the call
         * @return Call* The current call
         */
        virtual Call* newOutgoingCall(const CallID& id, const std::string& toUrl) = 0;
        /**
         * Answer the call
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool answer(const CallID& id) = 0;
    
        /**
         * Hang up a call
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool hangup(const CallID& id) = 0;
    
        /**
         * Cancel the call dialing
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool cancel(const CallID& id) = 0;
    
        /**
         * Put a call on hold
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool onhold(const CallID& id) = 0;
    
        /**
         * Resume a call from hold state
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool offhold(const CallID& id) = 0;
    
        /**
         * Transfer a call to specified URI
         * @param id The call identifier
         * @param to The recipient of the call
         * @return bool True on success
         */
        virtual bool transfer(const CallID& id, const std::string& to) = 0;
    
        /**
         * Refuse incoming call
         * @param id The call identifier
         * @return bool True on success
         */
        virtual bool refuse(const CallID& id) = 0;
    
        /**
         * Send DTMF
         * @param id The call identifier
         * @param code  The char code
         * @return bool True on success
         */
        virtual bool carryingDTMFdigits(const CallID& id, char code) = 0;
    
        /**
         * Send text message
         */
        virtual bool sendMessage(const std::string& to, const std::string& body) = 0;
    
        // NOW
        /**
         * Determine if link supports presence information
         */
        virtual bool isContactPresenceSupported() = 0;
    
        /**
         * Register contacts for presence information if supported
         */
        //virtual void subscribePresenceForContact(Contact* contact);
    
        /**
         * Publish presence status to server
         */
        virtual void publishPresenceStatus(std::string status);
    
        /**
         * Set the account full name
         * @param fullname	The full name
         */
        void setFullName (const std::string& fullname) { _fullname = fullname; }
    
        /**
         * Get the account full name
         * @return std::string The full name
         */
        std::string& getFullName (void) { return _fullname; }
    
        /**
         * Set the account host name
         * @param hostname	The host name
         */
        void setHostName (const std::string& hostname) {  _hostname = hostname; }
        
        /**
         * Get the account host name
         * @return std::string  The host name
         */
        std::string& getHostName (void) { return _hostname; }
    
        /**
         * @return AccountID  parent Account's ID
         */
        AccountID& getAccountID(void) { return _accountID; }
    
        /**
         * @param accountID The account identifier
         */
        void setAccountID( const AccountID& accountID) { _accountID = accountID; }
    
        /** Get the call pointer from the call map (protected by mutex)
         * @param id A Call ID
         * @return Call*  Call pointer or 0
         */
        Call* getCall(const CallID& id);
    
        /**
         * Get registration state
         * @return RegistrationState
         */
        enum RegistrationState getRegistrationState() { return _registrationState; }
    
        /**
         * Get registration error message, if set.
         */
        int getRegistrationError() { return _registrationError; }
    
        /**
         * Set new registration state
         * We use this function, in case the server needs to PUSH to the
         * GUI when the state changes.
         * @param state The registration state
         * @param errorCode The error code
         */
        void setRegistrationState(const enum RegistrationState state,
    	const int& errorCode);
    
        /**
         * Set new registration state
         * @param state The registration state
         */
        void setRegistrationState(const enum RegistrationState state);
    
      private:
        /**
         * Full name used as outgoing Caller ID
         */
        std::string _fullname;
    
        /**
         * Host name used for authentication
         */
        std::string _hostname;
    
        /**
         * ID of parent's Account
         */
        AccountID _accountID;
    
        /**
         * State of registration
         */
        enum RegistrationState _registrationState;
    
        /**
         * Registration error code -> refers to global.h
         */
        int _registrationError;
    
      //protected:
    public:
        /** Add a call to the call map (protected by mutex)
         * @param call A call pointer with a unique pointer
         * @return bool True if the call was unique and added
         */
        bool addCall(Call* call);
    
        /** Remove a call from the call map (protected by mutex)
         * @param id A Call ID
         * @return bool True if the call was correctly removed
         */
        bool removeCall(const CallID& id);
    
        /**
         * Remove all the call from the map
         * @return bool True on success
         */
        bool clearCallMap();
        
        
    protected:
        /** Contains all the calls for this Link, protected by mutex */
        CallMap _callMap;
    
        /** Mutex to protect call map */
        ost::Mutex _callMapMutex;
    
        /** Get Local IP Address (ie: 127.0.0.1, 192.168.0.1, ...) */
        std::string _localIPAddress;
    
        /** Get local listening port (5060 for SIP, ...) */
        unsigned int _localPort;
    
        /** Whether init() was called already or not
         * This should be used in [IAX|SIP]VoIPLink::init() and terminate(), to
         * indicate that init() was called, or reset by terminate().
         */
        bool _initDone;
    };
    
    #endif // __VOIP_LINK_H__