managerimpl.cpp

/*
 *  Copyright (C) 2004-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>
 *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
 *  Author: Guillaume Carmel-Archambault <guillaume.carmel-archambault@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 3 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.
 */

#include <errno.h>
#include <time.h>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <sys/types.h> // mkdir(2)
#include <sys/stat.h>	// mkdir(2)

#include <cc++/socket.h>   // why do I need this here?
#include <ccrtp/channel.h> // why do I need this here?
#include <ccrtp/rtp.h>     // why do I need this here?
#include <cc++/file.h>

#include "conference.h"

#include "manager.h"
#include "account.h"
#include "sipaccount.h"
#include "audio/audiolayer.h"
#include "audio/alsalayer.h"
#include "audio/pulselayer.h"
#include "audio/tonelist.h"

#include "accountcreator.h" // create new account
#include "sipvoiplink.h"

#include "user_cfg.h"

#define fill_config_str(name, value) \
  (_config.addConfigTreeItem(section, Conf::ConfigTreeItem(std::string(name), std::string(value), type_str)))
#define fill_config_int(name, value) \
  (_config.addConfigTreeItem(section, Conf::ConfigTreeItem(std::string(name), std::string(value), type_int)))

ManagerImpl::ManagerImpl (void)
        : _hasTriedToRegister (false)
        , _config()
        , _currentCallId2()
        , _currentCallMutex()
        , _codecBuilder (NULL)
        , _audiodriver (NULL)
        , _dtmfKey (NULL)
        , _codecDescriptorMap()
        , _toneMutex()
        , _telephoneTone (NULL)
        , _audiofile()
        , _spkr_volume (0)
        , _mic_volume (0)
        , _mutex()
        , _dbus (NULL)
        , _waitingCall()
        , _waitingCallMutex()
        , _nbIncomingWaitingCall (0)
        , _path ("")
        , _exist (0)
        , _setupLoaded (false)
        , _firewallPort()
        , _firewallAddr ("")
        , _hasZeroconf (false)
        , _callAccountMap()
        , _callAccountMapMutex()
        , _callConfigMap()
        , _accountMap()
        , _cleaner (NULL)
        , _history (NULL)
{

    // initialize random generator for call id
    srand (time (NULL));

    _cleaner = new NumberCleaner ();
    _history = new HistoryManager ();

#ifdef TEST
    testAccountMap();
    loadAccountMap();
    testCallAccountMap();
    unloadAccountMap();
#endif

    // should be call before initConfigFile
    // loadAccountMap();, called in init() now.
}

// never call if we use only the singleton...
ManagerImpl::~ManagerImpl (void)
{
    // terminate();
    delete _cleaner;
    _cleaner=0;
    _debug ("%s stop correctly.\n", PROGNAME);
}

void
ManagerImpl::init()
{
    // Load accounts, init map
    loadAccountMap();

    initVolume();

    if (_exist == 0) {
        _debug ("Cannot create config file in your home directory\n");
    }

    initAudioDriver();

    selectAudioDriver();

    // Initialize the list of supported audio codecs
    initAudioCodec();

    AudioLayer *audiolayer = getAudioDriver();

    if (audiolayer != 0) {
        unsigned int sampleRate = audiolayer->getSampleRate();

        _debugInit ("Load Telephone Tone");
        std::string country = getConfigString (PREFERENCES, ZONE_TONE);
        _telephoneTone = new TelephoneTone (country, sampleRate);

        _debugInit ("Loading DTMF key");
        _dtmfKey = new DTMF (sampleRate);
    }

    if (audiolayer == 0)
        audiolayer->stopStream();


    // Load the history
    _history->load_history (getConfigInt (PREFERENCES, CONFIG_HISTORY_LIMIT));
}

void ManagerImpl::terminate()
{
    _debug ("ManagerImpl::terminate \n");
    saveConfig();

    unloadAccountMap();

    _debug ("Unload DTMF Key \n");
    delete _dtmfKey;

    _debug ("Unload Audio Driver \n");
    delete _audiodriver;
    _audiodriver = NULL;

    _debug ("Unload Telephone Tone \n");
    delete _telephoneTone;
    _telephoneTone = NULL;

    _debug ("Unload Audio Codecs \n");
    _codecDescriptorMap.deleteHandlePointer();

}

bool
ManagerImpl::isCurrentCall (const CallID& callId)
{
    return (_currentCallId2 == callId ? true : false);
}

bool
ManagerImpl::hasCurrentCall()
{
    _debug ("ManagerImpl::hasCurrentCall current call ID = %s\n", _currentCallId2.c_str());

    if (_currentCallId2 != "") {
        return true;
    }

    return false;
}

const CallID&
ManagerImpl::getCurrentCallId()
{
    return _currentCallId2;
}

void
ManagerImpl::switchCall (const CallID& id)
{
    ost::MutexLock m (_currentCallMutex);
    _debug("------------------------- SWITCH %s ---------------------------\n", id.c_str());
    _currentCallId2 = id;
}


///////////////////////////////////////////////////////////////////////////////
// Management of events' IP-phone user
///////////////////////////////////////////////////////////////////////////////
/* Main Thread */

bool
ManagerImpl::outgoingCall (const std::string& accountid, const CallID& id, const std::string& to)
{
    std::string pattern, to_cleaned;
    Call::CallConfiguration callConfig;
    SIPVoIPLink *siplink;

    _debug ("ManagerImpl::outgoingCall(%s)\n", id.c_str());

    if (getConfigString (HOOKS, PHONE_NUMBER_HOOK_ENABLED) ==  "1")
        _cleaner->set_phone_number_prefix (getConfigString (HOOKS, PHONE_NUMBER_HOOK_ADD_PREFIX));
    else
        _cleaner->set_phone_number_prefix ("");

    to_cleaned = _cleaner->clean (to);

    /* Check what kind of call we are dealing with */
    check_call_configuration (id, to_cleaned, &callConfig);

    if (hasCurrentCall()) {
	
	_debug ("ManagerImpl::outgoingCall() Has current call (id %s) put it onhold\n", getCurrentCallId().c_str());	
	// if this is not a conferenceand this and is not a conference participant
	if (!isConference(getCurrentCallId()) && !participToConference(getCurrentCallId()))
	{
	    _debug ("ManagerImpl::outgoingCall() Put the current call (ID=%s) on hold\n", getCurrentCallId().c_str());
	    onHoldCall (getCurrentCallId());
	}
	else if (isConference(getCurrentCallId()))
	{
	    _debug ("ManagerImpl::outgoingCall() detach main participant from conference\n");
	    detachParticipant();
	}
    }

    if (callConfig == Call::IPtoIP) {
        _debug ("ManagerImpl::outgoingCall Start IP to IP call\n");
        /* We need to retrieve the sip voiplink instance */
        siplink = SIPVoIPLink::instance ("");

        if (siplink->new_ip_to_ip_call (id, to_cleaned)) {
            switchCall (id);
            return true;
        } else {
            callFailure (id);
        }

        return false;
    }

    if (!accountExists (accountid)) {
        _debug ("! Manager Error: Outgoing Call: account doesn't exist\n");
        return false;
    }

    if (getAccountFromCall (id) != AccountNULL) {
        _debug ("! Manager Error: Outgoing Call: call id already exists\n");
        return false;
    }


    _debug ("- Manager Action: Adding Outgoing Call %s on account %s\n", id.data(), accountid.data());

    associateCallToAccount (id, accountid);

    if (getAccountLink (accountid)->newOutgoingCall (id, to_cleaned)) {
        switchCall (id);
        return true;
    } else {
        callFailure (id);
        _debug ("! Manager Error: An error occur, the call was not created\n");
    }

    return false;
}

//THREAD=Main : for outgoing Call
bool
ManagerImpl::answerCall (const CallID& id)
{

    _debug("ManagerImpl::answerCall(%s)", id.c_str());

    stopTone (true);

    AccountID currentAccountId;
    currentAccountId = getAccountFromCall (id);
    if(currentAccountId == AccountNULL) {
        _debug("ManagerImpl::answerCall : AccountId is null\n");
        return false;
    }
    
    Call* currentCall = NULL;
    currentCall = getAccountLink (currentAccountId)->getCall (id);
    if (currentCall == NULL) {
        _debug("ManagerImpl::answerCall : currentCall is null\n");
    }
    /*
    Call* lastCall = NULL;
    if (!getCurrentCallId().empty()) {
        lastCall = getAccountLink (currentAccountId)->getCall (getCurrentCallId());
        if (lastCall == NULL) {
            _debug("ManagerImpl::answerCall : lastCall is null\n");
        }
    }

    _debug ("ManagerImpl::answerCall :: current call->getState %i \n", currentCall->getState());
    _debug ("Try to answer call: %s\n", id.data());

    if (lastCall != NULL ) {
        if (lastCall->getState() == Call::Active && !participToConference(getCurrentCallId())) {
            _debug ("* Manager Info: there is currently a call, try to hold it\n");
            onHoldCall (getCurrentCallId());
        }
	else if (isConference(getCurrentCallId()))
	{
	    _debug("Current call particips to a conference! Do not hold it!\n");
	}
    }
    */
    if (hasCurrentCall()) {
	
	_debug ("ManagerImpl::answerCall() Has current call (id %s) put it onhold\n", getCurrentCallId().c_str());	
	// if this is not a conferenceand this and is not a conference participant
	if (!isConference(getCurrentCallId()) && !participToConference(getCurrentCallId()))
	{
	    _debug ("ManagerImpl::answerCall() Put the current call (ID=%s) on hold\n", getCurrentCallId().c_str());
	    onHoldCall (getCurrentCallId());
	}
	else if (isConference(getCurrentCallId()) && !participToConference(id))
	{
	    _debug ("ManagerImpl::answerCall() detach main participant from conference\n");
	    detachParticipant();
	}
    }

    if (!getAccountLink (currentAccountId)->answer (id)) {
        // error when receiving...
        removeCallAccount (id);
        return false;
    }

    // if it was waiting, it's waiting no more
    if (_dbus) _dbus->getCallManager()->callStateChanged (id, "CURRENT");
        
    std::string codecName = Manager::instance().getCurrentCodecName (id);
    if (_dbus) _dbus->getCallManager()->currentSelectedCodec (id,codecName.c_str());
        
    removeWaitingCall (id);

    switchCall (id);

    return true;
}

//THREAD=Main
bool
ManagerImpl::hangupCall (const CallID& id)
{
    _debug ("ManagerImpl::hangupCall()\n");
    PulseLayer *pulselayer;
    AccountID accountid;
    bool returnValue;
    AudioLayer *audiolayer;

    CallID current_call_id = getCurrentCallId();

    stopTone (false);
    switchCall (id);

    /* Broadcast a signal over DBus */

    _debug("ManagerImpl::hangupCall: Send DBUS call state change (HUNGUP) for id %s\n", id.c_str());
    if (_dbus) _dbus->getCallManager()->callStateChanged (id, "HUNGUP");

    int nbCalls = getCallList().size();

    audiolayer = getAudioDriver();
    // stop streamx
    if (! (nbCalls >= 1))
    {
	_debug("ManagerImpl::stop audio stream, ther is only %i call(s) remaining\n", nbCalls);
        audiolayer->stopStream();
    }
   
    if(participToConference(id))
    {

	AccountID currentAccountId;
	Call* call = NULL;

	currentAccountId = getAccountFromCall (id);
	call = getAccountLink (currentAccountId)->getCall (id);

	ConferenceMap::iterator iter = _conferencemap.find(call->getConfId());
	if(iter != _conferencemap.end())
	{

	    Conference *conf = iter->second;

	    removeParticipant(id);
	    
	    if(conf->getNbParticipants() > 1)
	    {
		switchCall(conf->getConfID());
	    }
	    else if (conf->getNbParticipants() == 1)
	    {
		AccountID currentAccountId;
		Call* call = NULL;
	    
		ParticipantSet participants = conf->getParticipantList();
		ParticipantSet::iterator iter_participant = participants.begin();
		
		// bind main participant to remaining conference call
		if (iter_participant != participants.end()) {
		    
		    // this call is no more a conference participant
		    currentAccountId = getAccountFromCall (*iter_participant);
		    call = getAccountLink (currentAccountId)->getCall (*iter_participant);
		    call->setConfId ("");
		    
		    if (current_call_id != conf->getConfID())
		    {
			onHoldCall(call->getCallId());
			switchCall(current_call_id);
		    }
		    else
		    {
			switchCall(*iter_participant);
		    }
		}
	    
		removeConference(conf->getConfID());
	    }
	    else
	    {
		removeConference(conf->getConfID());
		
		switchCall("");
	    }
	}
    }

    /* Direct IP to IP call */
    if (getConfigFromCall (id) == Call::IPtoIP) {
        returnValue = SIPVoIPLink::instance (AccountNULL)->hangup (id);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) 
	{
            _debug ("! Manager Hangup Call: Call doesn't exists\n");
            return false;
        }

        returnValue = getAccountLink (accountid)->hangup (id);

        removeCallAccount (id);
    }

    _debug("ManagerImpl::hangupCall CURRENT CALL ID %s\n", getCurrentCallId().c_str());

    switchCall ("");

    _debug("ManagerImpl::hangupCall CURRENT CALL ID %s\n", getCurrentCallId().c_str());

    if (_audiodriver->getLayerType() == PULSEAUDIO && getConfigInt (PREFERENCES , CONFIG_PA_VOLUME_CTRL)) {
        pulselayer = dynamic_cast<PulseLayer *> (getAudioDriver());

        if (pulselayer)  pulselayer->restorePulseAppsVolume();
    }

    return returnValue;
}


bool
ManagerImpl::hangupConference (const ConfID& id)
{
    _debug ("ManagerImpl::hangupConference()\n");

    Conference *conf;
    ConferenceMap::iterator iter_conf = _conferencemap.find(id);

    AccountID currentAccountId;

    // Call* call = NULL;

    if(iter_conf != _conferencemap.end())
    {
	conf = iter_conf->second;
 
	ParticipantSet participants = conf->getParticipantList();
	ParticipantSet::iterator iter_participant = participants.begin();

	while(iter_participant != participants.end())
	{
	    _debug("ManagerImpl::hangupConference participant %s\n", (*iter_participant).c_str());

	    hangupCall (*iter_participant);

	    iter_participant++;

	}

    }

    switchCall ("");

    return true;
}


//THREAD=Main
bool
ManagerImpl::cancelCall (const CallID& id)
{
    AccountID accountid;
    bool returnValue;

    stopTone (true);

    /* Direct IP to IP call */

    if (getConfigFromCall (id) == Call::IPtoIP) {
        returnValue = SIPVoIPLink::instance (AccountNULL)->cancel (id);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) {
            _debug ("! Manager Cancel Call: Call doesn't exists\n");
            return false;
        }

        returnValue = getAccountLink (accountid)->cancel (id);

        removeCallAccount (id);
    }

    // it could be a waiting call?
    removeWaitingCall (id);

    switchCall ("");

    return returnValue;
}

//THREAD=Main
bool
ManagerImpl::onHoldCall (const CallID& id)
{
    AccountID accountid;
    bool returnValue;
    CallID call_id;

    stopTone (true);

    call_id = id;

    switchCall (id);

    /* Direct IP to IP call */

    if (getConfigFromCall (id) == Call::IPtoIP) {
        returnValue = SIPVoIPLink::instance (AccountNULL)-> onhold (id);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) {
            _debug ("Manager On Hold Call: Account ID %s or callid %s doesn't exists\n", accountid.c_str(), id.c_str());
            return false;
        }

        returnValue = getAccountLink (accountid)->onhold (id);
    }
    
    removeWaitingCall (id);

    switchCall ("");

    if (_dbus) _dbus->getCallManager()->callStateChanged (call_id, "HOLD");

    return returnValue;
}

//THREAD=Main
bool
ManagerImpl::offHoldCall (const CallID& id)
{

    AccountID accountid;
    bool returnValue, rec;
    std::string codecName;
    CallID call_id, current_call_id;

    stopTone (false);

    call_id = id;
    current_call_id = getCurrentCallId();
    //Place current call on hold if it isn't

    if (hasCurrentCall()) 
    {
	// if this is not a conferenceand this and is not a conference participant
	if (!isConference(current_call_id) && !participToConference(current_call_id))
	{
	    _debug ("ManagerImpl::offHoldCall put current call (ID=%s) on hold\n", current_call_id.c_str());
	    onHoldCall (current_call_id);
	}
	else if (isConference(current_call_id))
	{
	    _debug ("ManagerImpl::offHoldCall Put current conference (ID=%s) on hold\n", current_call_id.c_str());
	    detachParticipant();
	}
    }

    // switch current call id to id since sipvoip link need it to amke a call 
    switchCall(id);

    /* Direct IP to IP call */
    if (getConfigFromCall (id) == Call::IPtoIP) {
        rec = SIPVoIPLink::instance (AccountNULL)-> isRecording (id);
        returnValue = SIPVoIPLink::instance (AccountNULL)-> offhold (id);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) {
            _debug ("Manager OffHold Call: Call doesn't exists\n");
            return false;
        }

        _debug ("Setting OFFHOLD, Account %s, callid %s\n", accountid.c_str(), id.c_str());

        rec = getAccountLink (accountid)->isRecording (id);
        returnValue = getAccountLink (accountid)->offhold (id);
    }


    if (_dbus) {
        if (rec)
            _dbus->getCallManager()->callStateChanged (call_id, "UNHOLD_RECORD");
        else
            _dbus->getCallManager()->callStateChanged (call_id, "UNHOLD_CURRENT");

    }

    if ( participToConference(id) ) {

	 
	AccountID currentAccountId;
        Call* call = NULL;

	currentAccountId = getAccountFromCall (id);
	call = getAccountLink (currentAccountId)->getCall (id);
	
	switchCall(call->getConfId());
    }
    // else the 
  

    codecName = getCurrentCodecName (id);
    // _debug("ManagerImpl::hangupCall(): broadcast codec name %s \n",codecName.c_str());

    if (_dbus) _dbus->getCallManager()->currentSelectedCodec (id,codecName.c_str());

    return returnValue;
}

//THREAD=Main
bool
ManagerImpl::transferCall (const CallID& id, const std::string& to)
{
    AccountID accountid;
    bool returnValue;

    stopTone (true);

    /* Direct IP to IP call */

    if (getConfigFromCall (id) == Call::IPtoIP) {
        returnValue = SIPVoIPLink::instance (AccountNULL)-> transfer (id, to);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) {
            _debug ("! Manager Transfer Call: Call doesn't exists\n");
            return false;
        }

        returnValue = getAccountLink (accountid)->transfer (id, to);

        removeCallAccount (id);
    }

    removeWaitingCall (id);

    switchCall ("");

    if (_dbus) _dbus->getCallManager()->callStateChanged (id, "HUNGUP");

    return returnValue;
}

void ManagerImpl::transferFailed()
{
    if (_dbus) _dbus->getCallManager()->transferFailed();
}

void ManagerImpl::transferSucceded()
{
    if (_dbus) _dbus->getCallManager()->transferSucceded();

}


//THREAD=Main : Call:Incoming
bool
ManagerImpl::refuseCall (const CallID& id)
{
    AccountID accountid;
    bool returnValue;

    stopTone (true);

    /* Direct IP to IP call */

    if (getConfigFromCall (id) == Call::IPtoIP) {
        returnValue = SIPVoIPLink::instance (AccountNULL)-> refuse (id);
    }

    /* Classic call, attached to an account */
    else {
        accountid = getAccountFromCall (id);

        if (accountid == AccountNULL) {
            _debug ("! Manager OffHold Call: Call doesn't exists\n");
            return false;
        }

        returnValue = getAccountLink (accountid)->refuse (id);

        removeCallAccount (id);
    }

    // if the call was outgoing or established, we didn't refuse it
    // so the method did nothing
    if (returnValue) {
        removeWaitingCall (id);

        if (_dbus) _dbus->getCallManager()->callStateChanged (id, "HUNGUP");

        switchCall ("");
    }

    return returnValue;
}


Conference*
ManagerImpl::createConference(const CallID& id1, const CallID& id2)
{
    _debug("ManagerImpl::createConference()\n");
    
    Conference* conf = new Conference();

    // _conferencecall.insert(pair<CallID, Conference*>(id1, conf));
    // _conferencecall.insert(pair<CallID, Conference*>(id2, conf));
    _conferencemap.insert(pair<CallID, Conference*>(conf->getConfID(), conf));

    conf->add(id1);
    conf->add(id2);

    // broadcast a signal over dbus
    _dbus->getCallManager()->conferenceCreated(conf->getConfID());
    
    return conf;
}

void
ManagerImpl::removeConference(const ConfID& conference_id)
{

    _debug("ManagerImpl::removeConference(%s)\n", conference_id.c_str());

    Conference* conf = NULL;

    _debug("ManagerImpl::removeConference _conferencemap.size: %i\n", _conferencemap.size());
    ConferenceMap::iterator iter = _conferencemap.find(conference_id);

    if (iter != _conferencemap.end()) {
	_debug("Found conference id %s in conferencemap\n", conference_id.c_str());
        conf = iter->second;
    }

    if(conf == NULL)
	return;


    /*
    // unbind main participant from conference
    _audiodriver->getMainBuffer()->unBindAll(default_id);

    ParticipantSet participants = conf->getParticipantList();

    // bind main participant to remaining conference call
    ParticipantSet::iterator iter_p = participants.begin();
    if (iter_p != participants.end()) {

	// to avoid puting onhold the call
	// switchCall("");	
	_audiodriver->getMainBuffer()->bindCallID(*iter_p, default_id);
    }