managerimpl.cpp

/*
 *  Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010, 2011 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: Alexandre Savard <alexandre.savard@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.
 *
 *  Additional permission under GNU GPL version 3 section 7:
 *
 *  If you modify this program, or any covered work, by linking or
 *  combining it with the OpenSSL project's OpenSSL library (or a
 *  modified version of that library), containing parts covered by the
 *  terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
 *  grants you additional permission to convey the resulting work.
 *  Corresponding Source for a non-source form of such a combination
 *  shall include the source code for the parts of OpenSSL used as well
 *  as that of the covered work.
 */

#include "config.h"

#include "managerimpl.h"

#include "account.h"
#include "dbus/callmanager.h"
#include "global.h"
#include "sip/sipaccount.h"

#include "audio/alsa/alsalayer.h"
#include "audio/pulseaudio/pulselayer.h"
#include "audio/sound/tonelist.h"
#include "history/historymanager.h"
#include "accountcreator.h" // create new account
#include "sip/sipvoiplink.h"
#include "iax/iaxvoiplink.h"
#include "manager.h"
#include "dbus/configurationmanager.h"

#include "conference.h"

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

ManagerImpl::ManagerImpl (void) :
    _hasTriedToRegister (false), _config(), _currentCallId2(),
    _currentCallMutex(), _audiodriver (0),
    _dtmfKey (0), _audioCodecFactory(), _toneMutex(),
    _telephoneTone (0), _audiofile (0), _spkr_volume (0),
    _mic_volume (0), _waitingCall(),
    _waitingCallMutex(), _nbIncomingWaitingCall (0), _path (""),
    _setupLoaded (false), _callAccountMap(),
    _callAccountMapMutex(), _callConfigMap(), _accountMap(),
    _directIpAccount (0), _cleaner (new NumberCleaner),
    _history (new HistoryManager), _imModule(new sfl::InstantMessaging),
    parser_(0)
{
    // initialize random generator for call id
    srand (time (NULL));
}

// never call if we use only the singleton...
ManagerImpl::~ManagerImpl (void)
{
    delete _imModule;
    delete _history;
    delete _cleaner;
	delete _audiofile;
}

void ManagerImpl::init ()
{
    // Load accounts, init map
    buildConfiguration();
    initVolume();
    initAudioDriver();
    selectAudioDriver();

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

    audioLayerMutexLock();

    if (_audiodriver) {
        unsigned int sampleRate = _audiodriver->getSampleRate();

        _debugInit ("Manager: Load telephone tone");
        std::string country(preferences.getZoneToneChoice());
        _telephoneTone = new TelephoneTone (country, sampleRate);

        _debugInit ("Manager: Loading DTMF key (%d)", sampleRate);

        sampleRate = 8000;

        _dtmfKey = new DTMF (sampleRate);
    }

    audioLayerMutexUnlock();

    // Load the history
    _history->load_history (preferences.getHistoryLimit());

    // Init the instant messaging module
    _imModule->init();

    // Register accounts
    initRegisterAccounts(); //getEvents();
}

void ManagerImpl::terminate ()
{
    _debug ("Manager: Terminate ");

    std::vector<std::string> callList(getCallList());
    _debug ("Manager: Hangup %d remaining call", callList.size());
    std::vector<std::string>::iterator iter = callList.begin();

    while (iter != callList.end()) {
        hangupCall (*iter);
        iter++;
    }

    unloadAccountMap();

    _debug ("Manager: Unload DTMF key");
    delete _dtmfKey;

    _debug ("Manager: Unload telephone tone");
    delete _telephoneTone;
    _telephoneTone = NULL;

    audioLayerMutexLock();

    _debug ("Manager: Unload audio driver");
    delete _audiodriver;
    _audiodriver = NULL;

    _debug ("Manager: Unload audio codecs ");
    _audioCodecFactory.deleteHandlePointer();
    audioLayerMutexUnlock();
}

bool ManagerImpl::isCurrentCall (const std::string& callId)
{
    return _currentCallId2 == callId;
}

bool ManagerImpl::hasCurrentCall ()
{
	return not _currentCallId2.empty();
}

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

void ManagerImpl::switchCall (const std::string& id)
{
    ost::MutexLock m (_currentCallMutex);
    _debug ("----- Switch current call id to %s -----", id.c_str());
    _currentCallId2 = id;
}

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

bool ManagerImpl::outgoingCall (const std::string& account_id,
                                const std::string& call_id, const std::string& to, const std::string& conf_id)
{

    std::string pattern, to_cleaned;
    Call::CallConfiguration callConfig;
    SIPVoIPLink *siplink;

    if (call_id.empty()) {
        _debug ("Manager: New outgoing call abbort, missing callid");
        return false;
    }

    // Call ID must be unique
    if (not getAccountFromCall (call_id).empty()) {
        _error ("Manager: Error: Call id already exists in outgoing call");
        return false;
    }

    _debug ("Manager: New outgoing call %s to %s", call_id.c_str(), to.c_str());

    stopTone();

    std::string current_call_id(getCurrentCallId());

    if (hookPreference.getNumberEnabled())
        _cleaner->set_phone_number_prefix (hookPreference.getNumberAddPrefix());
    else
        _cleaner->set_phone_number_prefix ("");

    to_cleaned = _cleaner->clean (to);

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

    // in any cases we have to detach from current communication
    if (hasCurrentCall()) {
        _debug ("Manager: Has current call (%s) put it onhold", current_call_id.c_str());

        // if this is not a conferenceand this and is not a conference participant
        if (!isConference (current_call_id) && !participToConference (current_call_id))
       	    onHoldCall (current_call_id);
        else if (isConference (current_call_id) && !participToConference (call_id))
            detachParticipant (Call::DEFAULT_ID, current_call_id);
    }

    if (callConfig == Call::IPtoIP) {
        _debug ("Manager: Start IP2IP call");
        /* We need to retrieve the sip voiplink instance */
        siplink = SIPVoIPLink::instance ();

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

        return false;
    }

    _debug ("Manager: Selecting account %s", account_id.c_str());

    // Is this account exist
    if (!accountExists (account_id)) {
        _error ("Manager: Error: Account doesn't exist in new outgoing call");
        return false;
    }

    if(!associateCallToAccount (call_id, account_id)) {
    	_warn("Manager: Warning: Could not associate call id %s to account id %s", call_id.c_str(), account_id.c_str());
    }

    Call *call = NULL;
    try {
        call = getAccountLink(account_id)->newOutgoingCall (call_id, to_cleaned);

        switchCall (call_id);

        call->setConfId(conf_id);
    } catch (const VoipLinkException &e) {
        callFailure (call_id);
        _error ("Manager: %s", e.what());
        return false;
    }

    getMainBuffer()->stateInfo();

    return true;
}

//THREAD=Main : for outgoing Call
bool ManagerImpl::answerCall (const std::string& call_id)
{
    _debug ("Manager: Answer call %s", call_id.c_str());

    // If sflphone is ringing
    stopTone();

    // store the current call id
    std::string current_call_id(getCurrentCallId());

    // Retreive call coresponding to this id
    std::string account_id = getAccountFromCall (call_id);
    Call *call = getAccountLink (account_id)->getCall (call_id);
    if (call == NULL) {
        _error("Manager: Error: Call is null");
    }

    // in any cases we have to detach from current communication
    if (hasCurrentCall()) {

        _debug ("Manager: Currently conversing with %s", current_call_id.c_str());

        if (!isConference(current_call_id) && !participToConference (current_call_id)) {
            // if it is not a conference and is not a conference participant
            _debug ("Manager: Answer call: Put the current call (%s) on hold", current_call_id.c_str());
            onHoldCall (current_call_id);
        } else if (isConference (current_call_id) && !participToConference (call_id)) {
            // if we are talking to a conference and we are answering an incoming call
            _debug ("Manager: Detach main participant from conference");
            detachParticipant (Call::DEFAULT_ID, current_call_id);
        }
    }

    try {
        if (!getAccountLink (account_id)->answer (call_id)) {
            removeCallAccount (call_id);
            return false;
        }
    }
    catch (const VoipLinkException &e) {
    	_error("Manager: Error: %s", e.what());
    }

    // if it was waiting, it's waiting no more
    removeWaitingCall (call_id);

    // if we dragged this call into a conference already
    if (participToConference (call_id))
        switchCall (call->getConfId());
    else
        switchCall (call_id);

    // Connect streams
    addStream (call_id);

    getMainBuffer()->stateInfo();

    // Start recording if set in preference
    if (audioPreference.getIsAlwaysRecording())
    	setRecordingCall(call_id);

    // update call state on client side
    if (audioPreference.getIsAlwaysRecording())
        _dbus.getCallManager()->callStateChanged (call_id, "RECORD");
    else
    	_dbus.getCallManager()->callStateChanged(call_id, "CURRENT");

    return true;
}

//THREAD=Main
bool ManagerImpl::hangupCall (const std::string& callId)
{
    bool returnValue = true;

    _info ("Manager: Hangup call %s", callId.c_str());

    // First stop audio layer if there is no call anymore
    if (getCallList().empty()) {

    	audioLayerMutexLock();

        if(_audiodriver == NULL) {
        	audioLayerMutexUnlock();
        	_error("Manager: Error: Audio layer was not instantiated");
        	return returnValue;
        }

        _debug ("Manager: stop audio stream, there is no call remaining");
        _audiodriver->stopStream();
        audioLayerMutexUnlock();
    }

    // store the current call id
    std::string currentCallId(getCurrentCallId());

    stopTone();

    /* Broadcast a signal over DBus */
    _debug ("Manager: Send DBUS call state change (HUNGUP) for id %s", callId.c_str());
    _dbus.getCallManager()->callStateChanged (callId, "HUNGUP");

    if (not isValidCall(callId) and not getConfigFromCall(callId) == Call::IPtoIP) {
    	_error("Manager: Error: Could not hang up call, call not valid");
        return false;
    }

    // Disconnect streams
    removeStream(callId);

    if (participToConference (callId)) {
    	Conference *conf = getConferenceFromCallID (callId);
        if (conf != NULL) {
            // remove this participant
            removeParticipant (callId);
            processRemainingParticipant (currentCallId, conf);
        }
    } else {
        // we are not participating to a conference, current call switched to ""
        if (!isConference (currentCallId))
            switchCall ("");
    }

    if (getConfigFromCall (callId) == Call::IPtoIP) {
        /* Direct IP to IP call */
        try {
            returnValue = SIPVoIPLink::instance()->hangup (callId);
        }
        catch (const VoipLinkException &e)
        {
            _error("%s", e.what());
            returnValue = 1;
        }
    }
    else {
    	std::string accountId (getAccountFromCall (callId));
        returnValue = getAccountLink (accountId)->hangup (callId);
        removeCallAccount (callId);
    }

    getMainBuffer()->stateInfo();

    return returnValue;
}

bool ManagerImpl::hangupConference (const std::string& id)
{
    _debug ("Manager: Hangup conference %s", id.c_str());

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

    std::string currentAccountId;

    if (iter_conf != _conferencemap.end()) {
        Conference *conf = iter_conf->second;

        ParticipantSet participants = conf->getParticipantList();
        ParticipantSet::iterator iter_participant = participants.begin();

        while (iter_participant != participants.end()) {
            _debug ("Manager: Hangup conference participant %s", (*iter_participant).c_str());

            hangupCall (*iter_participant);

            iter_participant++;
        }
    }

    switchCall ("");

    getMainBuffer()->stateInfo();

    return true;
}

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

    _debug ("Manager: Cancel call");

    stopTone();

    /* Direct IP to IP call */

    if (getConfigFromCall (id) == Call::IPtoIP)
        returnValue = SIPVoIPLink::instance()->cancel (id);
    else {
        /* Classic call, attached to an account */
        accountid = getAccountFromCall (id);

        if (accountid.empty()) {
            _debug ("! Manager Cancel Call: Call doesn't exists");
            return false;
        }

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

        removeCallAccount (id);
    }

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

    removeStream (id);

    switchCall ("");

    getMainBuffer()->stateInfo();

    return returnValue;
}

//THREAD=Main
bool ManagerImpl::onHoldCall (const std::string& callId)
{
    bool returnValue = false;

    _debug ("Manager: Put call %s on hold", callId.c_str());

    stopTone();

    std::string current_call_id = getCurrentCallId();

    try {

    	if (getConfigFromCall (callId) == Call::IPtoIP) {
    		/* Direct IP to IP call */
    		returnValue = SIPVoIPLink::instance ()-> onhold (callId);
    	}
    	else {
    		/* Classic call, attached to an account */
            std::string account_id(getAccountFromCall (callId));

    		if (account_id == "") {
    			_debug ("Manager: Account ID %s or callid %s doesn't exists in call onHold", account_id.c_str(), callId.c_str());
    			return false;
    		}
    		returnValue = getAccountLink (account_id)->onhold (callId);
    	}
    }
    catch (const VoipLinkException &e){
    	_error("Manager: Error: %s", e.what());
    }

    // Unbind calls in main buffer
    removeStream (callId);

    // Remove call from teh queue if it was still there
    removeWaitingCall (callId);

    // keeps current call id if the action is not holding this call or a new outgoing call
    // this could happen in case of a conference
    if (current_call_id == callId)
        switchCall ("");

    _dbus.getCallManager()->callStateChanged (callId, "HOLD");

    getMainBuffer()->stateInfo();

    return returnValue;
}

//THREAD=Main
bool ManagerImpl::offHoldCall (const std::string& callId)
{
    std::string accountId;
    bool returnValue = true;
    std::string codecName;

    _debug ("Manager: Put call %s off hold", callId.c_str());

    stopTone();

    std::string currentCallId = getCurrentCallId();

    //Place current call on hold if it isn't

    if (hasCurrentCall()) {

        // if this is not a conference and this and is not a conference participant
        if (!isConference (currentCallId) && !participToConference (currentCallId)) {
        	_debug ("Manager: Has current call (%s), put on hold", currentCallId.c_str());
            onHoldCall (currentCallId);
        } else if (isConference (currentCallId) && !participToConference (callId))
            detachParticipant (Call::DEFAULT_ID, currentCallId);
    }

    bool isRec = false;

    /* Direct IP to IP call */
    if (getConfigFromCall (callId) == Call::IPtoIP)
        returnValue = SIPVoIPLink::instance ()-> offhold (callId);
    else {
        /* Classic call, attached to an account */
        accountId = getAccountFromCall (callId);

        _debug ("Manager: Setting offhold, Account %s, callid %s", accountId.c_str(), callId.c_str());

        Call * call = getAccountLink (accountId)->getCall (callId);
        if (call)
        {
            isRec = call->isRecording();
            returnValue = getAccountLink (accountId)->offhold (callId);
        }
    }

    _dbus.getCallManager()->callStateChanged (callId, isRec ? "UNHOLD_RECORD" : "UNHOLD_CURRENT");

    if (participToConference (callId)) {
        std::string currentAccountId;

        currentAccountId = getAccountFromCall (callId);
        Call *call = getAccountLink (currentAccountId)->getCall (callId);

        if (call)
            switchCall (call->getConfId());

    } else
        switchCall (callId);

    addStream(callId);

    getMainBuffer()->stateInfo();

    return returnValue;
}

//THREAD=Main
bool ManagerImpl::transferCall (const std::string& callId, const std::string& to)
{
    bool returnValue = false;;

    _info ("Manager: Transfer call %s", callId.c_str());

    std::string currentCallId = getCurrentCallId();

    if (participToConference(callId)) {
        Conference *conf = getConferenceFromCallID(callId);
        if (conf == NULL)
            _error("Manager: Error: Could not find conference from call id");

        removeParticipant (callId);
        processRemainingParticipant (callId, conf);
    }
    else if (!isConference(currentCallId))
            switchCall("");

    // Direct IP to IP call
    if (getConfigFromCall (callId) == Call::IPtoIP)
        returnValue = SIPVoIPLink::instance ()-> transfer (callId, to);
    else {
        std::string accountid (getAccountFromCall (callId));

        if (accountid == "") {
            _warn ("Manager: Call doesn't exists");
            return false;
        }

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

    // remove waiting call in case we make transfer without even answer
    removeWaitingCall (callId);

    getMainBuffer()->stateInfo();

    return returnValue;
}

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

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

bool ManagerImpl::attendedTransfer(const std::string& transferID, const std::string& targetID)
{
    bool returnValue = false;

    _debug("Manager: Attended transfer");

    // Direct IP to IP call
    if (getConfigFromCall (transferID) == Call::IPtoIP)
        returnValue = SIPVoIPLink::instance ()-> attendedTransfer(transferID, targetID);
    else {	// Classic call, attached to an account

        std::string accountid = getAccountFromCall (transferID);

        if (accountid.empty()) {
            _warn ("Manager: Call doesn't exists");
            return false;
        }

        returnValue = getAccountLink (accountid)->attendedTransfer (transferID, targetID);
    }

    getMainBuffer()->stateInfo();

    return returnValue;