added some missing files

src/audio/audiodevice.h

+/**
+ *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
+ *  Author:  Jean-Philippe Barrette-LaPierre 
+ *              <jean-philippe.barrette-lapierre@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 _AUDIO_DEVICE_H
+#define _AUDIO_DEVICE_H
+
+struct AudioDevice 
+{
+  const char *hostApiName;
+  const char *deviceName;
+};
+
+
+#endif

src/managerimpl.cpp

+/**
+ *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
+ *  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.
+ */
+
+#include <errno.h>
+#include <time.h>
+
+# include <sys/types.h> // mkdir(2)
+# include <sys/stat.h>	// mkdir(2)
+
+#include <sys/socket.h> // inet_ntoa()
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <cc++/thread.h>
+#include <cstdlib> 
+#include <iostream>
+#include <fstream> 
+#include <string>
+#include <vector>
+
+#include "manager.h"
+#include "audio/audiocodec.h"
+#include "audio/audiolayer.h"
+#include "audio/codecDescriptor.h"
+#include "audio/ringbuffer.h"
+#include "audio/tonegenerator.h"
+#include "call.h"
+#include "configuration.h"  
+#include "configurationtree.h" 
+#include "error.h"
+#include "sipvoiplink.h"
+#include "skin.h" 
+#include "user_cfg.h"
+#include "voIPLink.h" 
+#include "gui/guiframework.h"
+
+using namespace std;
+using namespace ost;
+ 
+ManagerImpl::ManagerImpl (void)
+{
+	// initialize random generator  
+  	srand (time(NULL));
+
+	// Init private variables 
+	_callVector = new CallVector();
+	_voIPLinkVector = new VoIPLinkVector();	
+	_error = new Error();
+	_tone = new ToneGenerator();	
+
+
+	_nCalls = 0;
+	_nCodecs = 0;
+	_currentCallId = 0;
+	_startTime = 0;
+	_endTime = 0;
+	_path = ""; 
+	_zonetone = false;
+	_congestion = false;
+	_ringtone = false;
+	_ringback = false;
+	_exist = 0;
+	_loaded = false;
+	
+}
+
+ManagerImpl::~ManagerImpl (void) 
+{
+	delete _callVector;
+	delete _voIPLinkVector;			
+	delete _error;
+	delete _tone;
+	delete _codecDescVector; 
+	delete _audiodriverPA;
+} 
+
+void 
+ManagerImpl::init (void) 
+{
+	// Set a sip voip link by default
+	_voIPLinkVector->push_back(new SipVoIPLink(DFT_VOIP_LINK));
+
+	initConfigFile();
+	_exist = createSettingsPath();
+	if (_exist == 0) {
+		_debug("Cannot create config file in your home directory\n");
+	} 
+	if (_exist == 2) {
+		// If config-file doesn't exist, launch configuration setup
+		_gui->setup();
+	}
+	initAudioCodec();
+
+	try {
+		selectAudioDriver();
+		loaded(true);
+	}
+	catch (const portaudio::PaException &e)
+	{
+		displayErrorText(e.paErrorText());
+	}
+	catch (const portaudio::PaCppException &e)
+	{
+		displayErrorText(e.what());
+	}
+	catch (const exception &e)
+	{
+		displayErrorText(e.what());
+	}
+	catch (...)
+	{ 
+		displayErrorText("An unknown exception occured.");
+	}
+	
+	_voIPLinkVector->at(DFT_VOIP_LINK)->init();
+
+	if (_voIPLinkVector->at(DFT_VOIP_LINK)->checkNetwork()) {
+	// If network is available
+		if (get_config_fields_int(SIGNALISATION, AUTO_REGISTER) == YES and 
+				_exist == 1) {
+			if (registerVoIPLink() != 1) {
+				_debug("Registration failed\n");
+				displayErrorText("Check your configuration fields");
+			}
+		} 
+	}
+}
+
+void
+ManagerImpl::setGui (GuiFramework* gui)
+{
+	_gui = gui;
+}
+
+ToneGenerator*
+ManagerImpl::getTonegenerator (void) 
+{
+	return _tone;
+}
+
+Error*
+ManagerImpl::error (void) 
+{
+	return _error;
+}
+
+AudioLayer*
+ManagerImpl::getAudioDriver(void) 
+{
+	return _audiodriverPA;
+}
+
+unsigned int 
+ManagerImpl::getNumberOfCalls (void)
+{
+	return _nCalls;
+}
+
+void 
+ManagerImpl::setNumberOfCalls (unsigned int nCalls)
+{
+	_nCalls = nCalls;
+}
+
+short
+ManagerImpl::getCurrentCallId (void)
+{
+	return _currentCallId;
+}
+
+void 
+ManagerImpl::setCurrentCallId (short currentCallId)
+{
+	_currentCallId = currentCallId;
+}
+
+CallVector* 
+ManagerImpl::getCallVector (void)
+{
+	return _callVector;
+}
+
+Call*
+ManagerImpl::getCall (short id)
+{
+	if (id > 0 and _callVector->size() > 0) {
+		for (unsigned int i = 0; i < _nCalls; i++) {
+			if (_callVector->at(i)->getId() == id) {
+				return _callVector->at(i);
+			}
+		}
+		return NULL;
+	} else {
+		return NULL;
+	}
+}
+
+
+unsigned int
+ManagerImpl::getNumberOfCodecs (void)
+{
+	return _nCodecs;
+}
+
+void
+ManagerImpl::setNumberOfCodecs (unsigned int nb_codec)
+{
+	_nCodecs = nb_codec;
+}
+
+VoIPLinkVector* 
+ManagerImpl::getVoIPLinkVector (void)
+{
+	return _voIPLinkVector;
+}
+
+CodecDescriptorVector*
+ManagerImpl::getCodecDescVector (void)
+{
+	return _codecDescVector;
+}
+
+void
+ManagerImpl::pushBackNewCall (short id, enum CallType type)
+{
+	Call* call = new Call(id, type, _voIPLinkVector->at(DFT_VOIP_LINK));
+	// Set the wanted voip-link (first of the list)
+	_callVector->push_back(call);
+}
+
+void
+ManagerImpl::deleteCall (short id)
+{
+	unsigned int i = 0;
+	while (i < _callVector->size()) {
+		if (_callVector->at(i)->getId() == id) {
+			_callVector->erase(_callVector->begin()+i);
+			return;
+		} else {
+			i++;
+		}
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Management of events' IP-phone user
+///////////////////////////////////////////////////////////////////////////////
+int 
+ManagerImpl::outgoingCall (const string& to)
+{	
+	short id;
+	Call* call;
+	
+	id = generateNewCallId();
+	pushBackNewCall(id, Outgoing);
+	
+	_debug("Outgoing Call with identifiant %d\n", id);
+	call = getCall(id);
+	if (call == NULL)
+		return 0;
+	
+	call->setStatus(string(TRYING_STATUS));
+	call->setState(Progressing);
+	if (call->outgoingCall(id, to) == 0) {
+		return id;
+	} else {
+		return 0;
+	}
+}
+
+int 
+ManagerImpl::hangupCall (short id)
+{
+	Call* call;
+
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(HUNGUP_STATUS));
+	call->setState(Hungup);
+	_mutex.enterMutex();
+	_nCalls -= 1;
+	_mutex.leaveMutex();
+	deleteCall(id);
+	if (getbRingback()) {
+		ringback(false);
+	}
+	return call->hangup();
+}
+
+int
+ManagerImpl::cancelCall (short id)
+{
+	Call* call;
+
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(HUNGUP_STATUS));
+	call->setState(Hungup);
+	_mutex.enterMutex();
+	_nCalls -= 1;
+	_mutex.leaveMutex();
+	deleteCall(id);
+	if (getbRingback()) {
+		ringback(false);
+	}
+	return call->cancel();
+}
+
+int 
+ManagerImpl::answerCall (short id)
+{
+	Call* call;
+
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(CONNECTED_STATUS));
+	call->setState(Answered);
+	ringtone(false);
+	return call->answer();
+}
+
+int 
+ManagerImpl::onHoldCall (short id)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(ONHOLD_STATUS));
+	call->setState(OnHold);
+	return call->onHold();
+}
+
+int 
+ManagerImpl::offHoldCall (short id)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(CONNECTED_STATUS));
+	call->setState(OffHold);
+	return call->offHold();	
+}
+
+int 
+ManagerImpl::transferCall (short id, const string& to)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(TRANSFER_STATUS));
+	call->setState(Transfered);
+	if (call->transfer(to) != 0) {
+		return -1;
+	} else {
+		return 1;
+	}
+}
+
+void 
+ManagerImpl::muteOn (short id)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return;
+	call->setStatus(string(MUTE_ON_STATUS));
+	call->setState(MuteOn);
+}
+
+void 
+ManagerImpl::muteOff (short id)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return;
+	call->setStatus(string(CONNECTED_STATUS));
+	call->setState(MuteOff);
+}
+
+int 
+ManagerImpl::refuseCall (short id)
+{
+	Call *call;
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setStatus(string(HUNGUP_STATUS));
+	call->setState(Refused);	
+	ringtone(false);
+	delete call;
+	return call->refuse();
+}
+
+int
+ManagerImpl::saveConfig (void)
+{
+	return (Config::tree()->saveToFile(_path.data()) ? 1 : 0);
+}
+
+int 
+ManagerImpl::registerVoIPLink (void)
+{
+	if (_voIPLinkVector->at(DFT_VOIP_LINK)->setRegister() == 0) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+int 
+ManagerImpl::quitApplication (void)
+{
+	// Quit VoIP-link library
+	_voIPLinkVector->at(DFT_VOIP_LINK)->quit();
+	if (saveConfig()) {
+		return 1;
+	} else {
+		return 0;
+	}
+	Config::deleteTree();
+}
+
+int 
+ManagerImpl::sendTextMessage (short , const string& )
+{
+	return 1;
+}
+
+int 
+ManagerImpl::accessToDirectory (void)
+{
+	return 1;
+}
+
+int 
+ManagerImpl::sendDtmf (short id, char code)
+{
+	int sendType = get_config_fields_int(SIGNALISATION, SEND_DTMF_AS);
+                                                                                
+    switch (sendType) {
+        // SIP INFO
+        case 0:
+			_voIPLinkVector->at(DFT_VOIP_LINK)->carryingDTMFdigits(id, code);
+			return 1;
+            break;
+                                                                                
+        // Audio way
+        case 1:
+			return 1;
+            break;
+                                                                                
+        // rfc 2833
+        case 2:
+			return 1;
+            break;
+                                                                                
+        default:
+			return -1;
+            break;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Management of event peer IP-phone 
+///////////////////////////////////////////////////////////////////////////////
+
+int 
+ManagerImpl::incomingCall (short id)
+{
+	Call* call;
+	call = getCall(id);
+	if (call == NULL)
+		return -1;
+	call->setType(Incoming);
+	call->setStatus(string(RINGING_STATUS));
+	call->setState(Progressing);
+	ringtone(true);
+	displayStatus(RINGING_STATUS);
+	return _gui->incomingCall(id);
+}
+
+// L'autre personne a repondu
+void 
+ManagerImpl::peerAnsweredCall (short id)
+{
+	Call* call;
+
+	if (getbRingback()) {
+		ringback(false);
+	}	
+	call = getCall(id);
+	call->setStatus(string(CONNECTED_STATUS));
+
+	call->setState(Answered);
+	if (isCurrentId(id)) {
+		_gui->peerAnsweredCall(id);
+	}
+}
+
+int 
+ManagerImpl::peerRingingCall (short id)
+{
+	Call* call;
+
+	call = getCall(id);
+	call->setStatus(string(RINGING_STATUS));
+	call->setState(Ringing);
+
+	ringback(true);
+	_gui->peerRingingCall(id);
+	displayStatus(RINGING_STATUS);	
+	return 1;
+}
+
+int 
+ManagerImpl::peerHungupCall (short id)
+{
+	Call* call;
+
+	call = getCall(id);
+	call->setStatus(string(HUNGUP_STATUS));
+	call->setState(Hungup);
+	_gui->peerHungupCall(id);
+	if (getbRingback()) {
+		ringback(false);
+	}
+	_mutex.enterMutex();
+	_nCalls -= 1;
+	_mutex.leaveMutex();
+	deleteCall(id);
+	return 1;
+}
+
+void 
+ManagerImpl::displayTextMessage (short id, const string& message)
+{
+	_gui->displayTextMessage(id, message);
+}
+
+void 
+ManagerImpl::displayErrorText (const string& message)
+{
+	_gui->displayErrorText(message);
+}
+
+void 
+ManagerImpl::displayError (const string& error)
+{
+	_gui->displayStatus(error);
+}
+
+void 
+ManagerImpl::displayStatus (const string& status)
+{
+	_gui->displayStatus(status);
+}
+
+int
+ManagerImpl::selectedCall (void) 
+{
+	return _gui->selectedCall();
+}
+
+bool
+ManagerImpl::isCurrentId (short id)
+{
+	return _gui->isCurrentId(id);
+}
+
+void
+ManagerImpl::congestion (bool var) {
+	if (isDriverLoaded()) {
+		if (_congestion != var) {
+			_congestion = var;
+		}
+		_zonetone = var;
+		_tone->toneHandle(ZT_TONE_CONGESTION);
+	} else {
+        _error->errorName(OPEN_FAILED_DEVICE);
+    }
+}
+
+void
+ManagerImpl::ringback (bool var) {
+	if (isDriverLoaded()) {
+		if (_ringback != var) {
+			_ringback = var;
+		}
+		_zonetone = var;
+		_tone->toneHandle(ZT_TONE_RINGTONE);
+	} else {
+        _error->errorName(OPEN_FAILED_DEVICE);
+    }
+}
+
+void
+ManagerImpl::ringtone (bool var) 
+{ 
+	if (isDriverLoaded()) {
+		if (getNumberOfCalls() > 1 and _zonetone and var == false) {
+			// If more than one line is ringing
+			_zonetone = false;
+			_tone->playRingtone((_gui->getRingtoneFile()).data());
+		}
+		
+		if (_ringtone != var) {
+			_ringtone = var;
+		}
+																					
+		_zonetone = var;
+		if (getNumberOfCalls() == 1) {
+			// If just one line is ringing
+			_tone->playRingtone((_gui->getRingtoneFile()).data());
+		} 
+	} else {
+        _error->errorName(OPEN_FAILED_DEVICE);
+    }
+}
+
+void
+ManagerImpl::notificationIncomingCall (void) {
+    int16* buf_ctrl_vol;
+    int16* buffer = new int16[SAMPLING_RATE];
+	int size = SAMPLING_RATE/2;
+	int k, spkrVolume;
+                                                                                
+    _tone->generateSin(440, 0, buffer);
+           
+	// Control volume
+	buf_ctrl_vol = new int16[size];
+	spkrVolume = getSpkrVolume();
+	for (int j = 0; j < size; j++) {
+		k = j*2;
+		buf_ctrl_vol[k] = buf_ctrl_vol[k+1] = buffer[j] * spkrVolume/100;
+	}
+	
+	getAudioDriver()->urgentRingBuffer().Put(buf_ctrl_vol, 
+			size * CHANNELS);
+
+	getAudioDriver()->startStream();
+	getAudioDriver()->sleep(NOTIFICATION_LEN);
+	getAudioDriver()->stopStream();
+	
+    delete[] buffer;
+    delete[] buf_ctrl_vol;
+}
+
+void
+ManagerImpl::getStunInfo (StunAddress4& stunSvrAddr) {
+    StunAddress4 mappedAddr;
+	struct in_addr in;
+	char* addr;
+	char to[16];
+	bzero (to, 16);
+                                                                                
+    int fd3, fd4;
+    bool ok = stunOpenSocketPair(stunSvrAddr,
+                                      &mappedAddr,
+                                      &fd3,
+                                      &fd4);
+    if (ok) {
+        closesocket(fd3);
+        closesocket(fd4);
+        _debug("Got port pair at %d\n", mappedAddr.port);
+        _firewallPort = mappedAddr.port;
+		
+		// Convert ipv4 address to host byte ordering
+		in.s_addr = ntohl (mappedAddr.addr);
+		addr = inet_ntoa(in);
+        _firewallAddr = string(addr);
+        _debug("address firewall = %s\n",_firewallAddr.data());
+    } else {
+        _debug("Opened a stun socket pair FAILED\n");
+    }
+}
+
+AudioDevice
+ManagerImpl::deviceList (int index)
+{
+  AudioDevice deviceParam;
+  deviceParam.hostApiName = 
+    portaudio::System::instance().deviceByIndex(index).hostApi().name();
+  deviceParam.deviceName = 
+    portaudio::System::instance().deviceByIndex(index).name();
+  return deviceParam;
+}
+
+int
+ManagerImpl::deviceCount (void)
+{
+	int numDevices = 0;
+	
+	portaudio::AutoSystem autoSys;
+	portaudio::System &sys = portaudio::System::instance();
+	numDevices = sys.deviceCount();
+	return numDevices;	
+}
+
+bool
+ManagerImpl::defaultDevice (int index) 
+{
+	bool defaultDisplayed = false;
+
+	portaudio::AutoSystem autoSys;
+	portaudio::System &sys = portaudio::System::instance(); 
+	if (sys.deviceByIndex(index).isSystemDefaultInputDevice()) {
+		defaultDisplayed = true;
+	}
+	return defaultDisplayed;
+}
+
+bool
+ManagerImpl::useStun (void) {
+    if (get_config_fields_int(SIGNALISATION, USE_STUN) == YES) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Private functions
+///////////////////////////////////////////////////////////////////////////////
+
+short 
+ManagerImpl::generateNewCallId (void)
+{
+	short random_id = rand();  
+	
+	// Check if already a call with this id exists 
+	while (getCall(random_id) != NULL or random_id <= 0) {
+		random_id = rand();
+	}
+	_mutex.enterMutex();
+	_nCalls += 1;
+	_mutex.leaveMutex();
+	// If random_id is not attributed, returns it.
+	return random_id;
+}
+
+unsigned int 
+ManagerImpl::callVectorSize (void)
+{
+	return _callVector->size();
+}
+
+int
+ManagerImpl::createSettingsPath (void) {
+	int exist = 1;
+  	_path = string(HOMEDIR) + "/." + PROGNAME;
+             
+  	if (mkdir (_path.data(), 0755) != 0) {
+		// If directory	creation failed
+    	if (errno != EEXIST) {
+			_debug("Cannot create directory: %d\n", strerror(errno));
+			return -1;
+      	} 	
+  	} 
+
+	// Load user's config
+	_path = _path + "/" + PROGNAME + "rc";
+
+	exist = Config::tree()->populateFromFile(_path);
+	
+	if (exist == 0){
+		// If populateFromFile failed
+		return 0;
+	} else if (exist == 2) {
+		// If  file doesn't exist yet
+		return 2;
+	}
+	return exist;
+}
+
+void
+ManagerImpl::initConfigFile (void) 
+{
+	fill_config_fields_int(SIGNALISATION, VOIP_LINK_ID, DFT_VOIP_LINK); 	
+	fill_config_fields_str(SIGNALISATION, FULL_NAME, EMPTY_FIELD);
+	fill_config_fields_str(SIGNALISATION, USER_PART, EMPTY_FIELD); 
+	fill_config_fields_str(SIGNALISATION, AUTH_USER_NAME, EMPTY_FIELD); 
+	fill_config_fields_str(SIGNALISATION, PASSWORD, EMPTY_FIELD); 
+	fill_config_fields_str(SIGNALISATION, HOST_PART, EMPTY_FIELD); 
+	fill_config_fields_str(SIGNALISATION, PROXY, EMPTY_FIELD); 
+	fill_config_fields_int(SIGNALISATION, AUTO_REGISTER, YES);
+	fill_config_fields_int(SIGNALISATION, PLAY_TONES, YES); 
+	fill_config_fields_int(SIGNALISATION, PULSE_LENGTH, DFT_PULSE_LENGTH); 
+	fill_config_fields_int(SIGNALISATION, SEND_DTMF_AS, SIP_INFO); 
+	fill_config_fields_str(SIGNALISATION, STUN_SERVER, DFT_STUN_SERVER); 
+	fill_config_fields_int(SIGNALISATION, USE_STUN, NO); 
+
+	fill_config_fields_int(AUDIO, DRIVER_NAME, DFT_DRIVER); 
+	fill_config_fields_int(AUDIO, NB_CODEC, DFT_NB_CODEC); 
+	fill_config_fields_str(AUDIO, CODEC1, DFT_CODEC); 
+	fill_config_fields_str(AUDIO, CODEC2, DFT_CODEC); 
+	fill_config_fields_str(AUDIO, CODEC3, DFT_CODEC); 
+	fill_config_fields_str(AUDIO, CODEC4, DFT_CODEC); 
+	fill_config_fields_str(AUDIO, CODEC5, DFT_CODEC); 
+	fill_config_fields_str(AUDIO, RING_CHOICE, DFT_RINGTONE); 
+	fill_config_fields_int(AUDIO, VOLUME_SPKR_X, DFT_VOL_SPKR_X); 
+	fill_config_fields_int(AUDIO, VOLUME_SPKR_Y, DFT_VOL_SPKR_Y); 
+	fill_config_fields_int(AUDIO, VOLUME_MICRO_X, DFT_VOL_MICRO_X); 
+	fill_config_fields_int(AUDIO, VOLUME_MICRO_Y, DFT_VOL_MICRO_Y); 
+
+	fill_config_fields_str(PREFERENCES, SKIN_CHOICE, DFT_SKIN); 
+	fill_config_fields_int(PREFERENCES, CONFIRM_QUIT, YES); 
+	fill_config_fields_str(PREFERENCES, ZONE_TONE, DFT_ZONE); 
+	fill_config_fields_int(PREFERENCES, CHECKED_TRAY, NO); 
+	fill_config_fields_str(PREFERENCES, VOICEMAIL_NUM, DFT_VOICEMAIL); 
+}
+
+void
+ManagerImpl::initAudioCodec (void)
+{
+	_nCodecs = get_config_fields_int(AUDIO, NB_CODEC);
+	_codecDescVector = new CodecDescriptorVector();
+	
+	_codecDescVector->push_back(new CodecDescriptor(
+				get_config_fields_str(AUDIO, CODEC1)));
+
+	_codecDescVector->push_back(new CodecDescriptor(
+				get_config_fields_str(AUDIO, CODEC2)));
+	
+	_codecDescVector->push_back(new CodecDescriptor(
+				get_config_fields_str(AUDIO, CODEC3)));
+}
+
+void
+ManagerImpl::selectAudioDriver (void)
+{
+	
+#if defined(AUDIO_PORTAUDIO)
+	_audiodriverPA = new AudioLayer();
+	_audiodriverPA->openDevice(get_config_fields_int(AUDIO, DRIVER_NAME));
+#else
+# error You must define one AUDIO driver to use.
+#endif
+}
+
+// EOF

src/managerimpl.h

+/**
+ *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
+ *  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 __MANAGER_H__
+#define __MANAGER_H__
+
+#include <cc++/thread.h>
+
+#include <string>
+#include <vector>
+
+#include "../stund/stun.h"
+#include "call.h"
+#include "audio/audiodevice.h"
+
+using namespace std;
+using namespace ost;
+
+class AudioLayer;
+class CodecDescriptor;
+class Error;
+class GuiFramework;
+class ToneGenerator;
+class VoIPLink;
+
+#define	NOTIFICATION_LEN	250
+// Status
+#define CONNECTED_STATUS	"Connected"
+#define LOGGED_IN_STATUS	"Logged in"
+#define RINGING_STATUS		"Ringing"
+#define TRYING_STATUS		"Trying ..."
+#define HUNGUP_STATUS       "Hung up"
+#define ONHOLD_STATUS       "On hold ..."
+#define TRANSFER_STATUS     "Transfer to:"
+#define MUTE_ON_STATUS		"Mute on"
+#define ENTER_NUMBER_STATUS "Enter Phone Number:"
+
+/*
+ * Define a type for a list of call
+ */
+typedef vector<Call*, allocator<Call*> > CallVector;
+
+/*
+ * Define a type for a list of VoIPLink
+ */
+typedef vector<VoIPLink*, allocator<VoIPLink*> > VoIPLinkVector;
+
+/*
+ * Define a type for a list of CodecDescriptor
+ */
+typedef vector<CodecDescriptor*, allocator<CodecDescriptor*> > CodecDescriptorVector;
+
+struct device_t{
+	const char* hostApiName;
+	const char* deviceName;
+};
+
+class ManagerImpl {
+public:
+	ManagerImpl (void);
+	~ManagerImpl (void);
+
+	void init (void);
+	void setGui (GuiFramework* gui);
+	ToneGenerator* getTonegenerator(void);
+	Error* error(void);
+	AudioLayer* getAudioDriver(void);
+
+	// Accessor to number of calls 
+	unsigned int getNumberOfCalls (void);
+	// Modifior of number of calls 
+	void setNumberOfCalls (unsigned int nCalls);
+	
+	// Accessor to current call id 
+	short getCurrentCallId (void);
+	// Modifior of current call id 
+	void setCurrentCallId (short currentCallId);
+
+	// Accessor to the Call vector 
+	CallVector* getCallVector (void);
+	// Accessor to the Call with the id 'id' 
+	Call* getCall (short id);
+	
+	unsigned int getNumberOfCodecs (void);
+	void setNumberOfCodecs (unsigned int nb_codec);
+	
+	VoIPLinkVector* getVoIPLinkVector (void);
+
+	CodecDescriptorVector* getCodecDescVector(void);
+
+	inline bool getZonetone (void) { return _zonetone; }
+	inline void setZonetone (bool b) { _zonetone = b; }
+
+	/* 
+	 * Attribute a new random id for a new call 
+	 * and check if it's already attributed to existing calls. 
+	 * If not exists, returns 'id' otherwise return 0 
+	 */   
+	short generateNewCallId (void);
+
+	/*
+	 * Add a new call at the end of the CallVector with identifiant 'id'
+	 */
+	void pushBackNewCall (short id, enum CallType type);
+	
+	/*
+	 * Erase the Call(id) from the CallVector
+	 */
+	void deleteCall	(short id);
+	
+	/*
+	 * Functions which occur with a user's action
+	 */
+	int outgoingCall (const string& to);
+	int hangupCall (short id);
+	int cancelCall (short id);
+	int answerCall (short id);
+	int onHoldCall (short id);
+	int offHoldCall (short id);
+	int transferCall (short id, const string& to);
+	void muteOn (short id);
+	void muteOff (short id);
+	int refuseCall (short id);
+
+	int saveConfig (void);
+	int registerVoIPLink (void);
+	int quitApplication (void);
+	int sendTextMessage (short id, const string& message);
+	int accessToDirectory (void);
+	
+	/**
+   	 * Handle choice of the DTMF-send-way
+ 	 *
+ 	 * @param   id: callid of the line.
+  	 * @param   code: pressed key.
+ 	 */
+	int sendDtmf (short id, char code);
+	
+
+	int incomingCall (short id);
+	void peerAnsweredCall (short id);
+	int peerRingingCall (short id);
+	int peerHungupCall (short id);
+	void displayTextMessage (short id, const string& message);
+	void displayErrorText (const string& message);
+	void displayError (const string& error);
+	void displayStatus (const string& status);
+	int selectedCall (void);
+	bool isCurrentId (short id);
+	
+	/*
+	 * Handle audio sounds heard by a caller while they wait for their 
+	 * connection to a called party to be completed.
+	 */
+	void ringback (bool var);
+
+	/*
+	 * Handle played music when an incoming call occurs
+	 */
+	void ringtone (bool var);
+
+	void congestion (bool var);
+
+	/*
+	 * Notification of incoming call when you are already busy
+	 */
+	void notificationIncomingCall (void);
+
+	/*
+	 * Get information about firewall 
+	 * @param	stunSvrAddr: stun server
+	 */
+	void getStunInfo (StunAddress4& stunSvrAddr);
+	bool useStun (void);
+	
+	inline bool getbCongestion 	(void) { return _congestion; }
+	inline bool getbRingback 	(void) { return _ringback; }
+	inline bool getbRingtone 	(void) { return _ringtone; }
+	
+	inline int getSpkrVolume 	(void) 			{ return _spkr_volume; }
+	inline void setSpkrVolume 	(int spkr_vol) 	{ _spkr_volume = spkr_vol; }
+	inline int getMicroVolume 	(void) 			{ return _mic_volume; }
+	inline void setMicroVolume 	(int mic_vol) 	{ _mic_volume = mic_vol; }
+	
+	inline int getFirewallPort 		(void) 		{ return _firewallPort; }
+	inline void setFirewallPort 	(int port) 	{ _firewallPort = port; }
+	inline string getFirewallAddress (void) 	{ return _firewallAddr; }
+
+	inline bool isDriverLoaded (void) { return _loaded; }
+	inline void loaded (bool l) { _loaded = l; }
+
+	/* 
+	 * Functions about audio device
+	 */
+	AudioDevice deviceList (int);
+	int deviceCount (void);
+	bool defaultDevice (int);
+	
+private:
+
+	/*
+	 * Returns the number of calls in the vector
+	 */
+	unsigned int callVectorSize (void);
+
+	/**
+ 	 * Create .PROGNAME directory in home user and create 
+	 * configuration tree from the settings file if this file exists.
+ 	 *
+ 	 * @return	0 if creating file failed
+	 *			1 if config-file exists
+	 *			2 if file doesn't exist yet.
+ 	 */
+	int createSettingsPath (void);
+		
+	/*
+	 * Init default values for the different fields
+	 */
+	void initConfigFile (void);
+
+	void initAudioCodec(void);
+	void selectAudioDriver (void);
+	
+/////////////////////
+// Private variables
+/////////////////////
+	ToneGenerator* _tone;
+	Error* _error;
+	GuiFramework* _gui;
+	AudioLayer* _audiodriverPA;
+
+	/*
+	 * Vector of VoIPLink
+	 */
+	VoIPLinkVector* _voIPLinkVector;
+	
+	/*
+	 * Vector of calls
+	 */
+	CallVector* _callVector;
+
+	/*
+	 * Vector of CodecDescriptor
+	 */
+	CodecDescriptorVector* _codecDescVector;
+
+	/*
+	 * Mutex to protect access to code section
+	 */
+	Mutex		_mutex;
+	
+	unsigned int _nCalls;
+	short _currentCallId;
+
+	/*
+	 * For the call timer
+	 */
+	unsigned int _startTime;
+	unsigned int _endTime;
+
+	/* Path of the ConfigFile 
+	 */
+	string 	_path;
+	int 	_exist;
+
+	unsigned int _nCodecs;
+	bool         _zonetone;
+	bool		 _congestion;
+	bool		 _ringback;
+	bool		 _ringtone;
+
+	// To handle volume control
+	int 		_spkr_volume;
+	int 		_mic_volume;
+
+	// To handle firewall
+	int			_firewallPort;
+	string		_firewallAddr;
+
+	// Variables used in exception
+	bool 		_loaded;
+};
+
+#endif // __MANAGER_H__