diff --git a/daemon/bin/dbus/configurationmanager-introspec.xml b/daemon/bin/dbus/configurationmanager-introspec.xml
index 4a7e65fc1fa2f70e64c21dfe7c6349b0c770ffcc..f898eea96d305867f098c94bfbfadbd43d7e355e 100644
--- a/daemon/bin/dbus/configurationmanager-introspec.xml
+++ b/daemon/bin/dbus/configurationmanager-introspec.xml
@@ -622,7 +622,7 @@
</arg>
</method>
- <method name="getTlsSettingsDefault" tp:name-for-bindings="getTlsSettingsDefault">
+ <method name="getTlsDefaultSettings" tp:name-for-bindings="getTlsDefaultSettings">
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringString"/>
<arg type="a{ss}" name="details" direction="out">
</arg>
diff --git a/daemon/bin/dbus/dbuscallmanager.cpp b/daemon/bin/dbus/dbuscallmanager.cpp
index 1d1d5213aca2cccdef01f26ce9021fccaad688ab..20d0ee772dc54698344b952fe93bd81f2112c225 100644
--- a/daemon/bin/dbus/dbuscallmanager.cpp
+++ b/daemon/bin/dbus/dbuscallmanager.cpp
@@ -27,217 +27,256 @@
* shall include the source code for the parts of OpenSSL used as well
* as that of the covered work.
*/
-#include <iostream>
-#include "dring.h"
#include "dbuscallmanager.h"
+#include "dring/callmanager_interface.h"
DBusCallManager::DBusCallManager(DBus::Connection& connection)
: DBus::ObjectAdaptor(connection, "/cx/ring/Ring/CallManager")
-{
-}
+{}
-bool DBusCallManager::placeCall(const std::string& accountID, const std::string& callID, const std::string& to)
+auto
+DBusCallManager::placeCall(const std::string& accountID, const std::string& callID, const std::string& to) -> decltype(DRing::placeCall(accountID, callID, to))
{
- return ring_call_place(accountID, callID, to);
+ return DRing::placeCall(accountID, callID, to);
}
-bool DBusCallManager::refuse(const std::string& callID)
+auto
+DBusCallManager::refuse(const std::string& callID) -> decltype(DRing::refuse(callID))
{
- return ring_call_refuse(callID);
+ return DRing::refuse(callID);
}
-bool DBusCallManager::accept(const std::string& callID)
+auto
+DBusCallManager::accept(const std::string& callID) -> decltype(DRing::accept(callID))
{
- return ring_call_accept(callID);
+ return DRing::accept(callID);
}
-bool DBusCallManager::hangUp(const std::string& callID)
+auto
+DBusCallManager::hangUp(const std::string& callID) -> decltype(DRing::hangUp(callID))
{
- return ring_call_hang_up(callID);
+ return DRing::hangUp(callID);
}
-bool DBusCallManager::hold(const std::string& callID)
+auto
+DBusCallManager::hold(const std::string& callID) -> decltype(DRing::hold(callID))
{
- return ring_call_hold(callID);
+ return DRing::hold(callID);
}
-bool DBusCallManager::unhold(const std::string& callID)
+auto
+DBusCallManager::unhold(const std::string& callID) -> decltype(DRing::unhold(callID))
{
- return ring_call_unhold(callID);
+ return DRing::unhold(callID);
}
-bool DBusCallManager::transfer(const std::string& callID, const std::string& to)
+auto
+DBusCallManager::transfer(const std::string& callID, const std::string& to) -> decltype(DRing::transfer(callID, to))
{
- return ring_call_transfer(callID, to);
+ return DRing::transfer(callID, to);
}
-bool DBusCallManager::attendedTransfer(const std::string& transferID, const std::string& targetID)
+auto
+DBusCallManager::attendedTransfer(const std::string& transferID, const std::string& targetID) -> decltype(DRing::attendedTransfer(transferID, targetID))
{
- return ring_call_attended_transfer(transferID, targetID);
+ return DRing::attendedTransfer(transferID, targetID);
}
-std::map< std::string, std::string > DBusCallManager::getCallDetails(const std::string& callID)
+auto
+DBusCallManager::getCallDetails(const std::string& callID) -> decltype(DRing::getCallDetails(callID))
{
- return ring_call_get_call_details(callID);
+ return DRing::getCallDetails(callID);
}
-std::vector< std::string > DBusCallManager::getCallList()
+auto
+DBusCallManager::getCallList() -> decltype(DRing::getCallList())
{
- return ring_call_get_call_list();
+ return DRing::getCallList();
}
-void DBusCallManager::removeConference(const std::string& conference_id)
+void
+DBusCallManager::removeConference(const std::string& conference_id)
{
- ring_call_remove_conference(conference_id);
+ DRing::removeConference(conference_id);
}
-bool DBusCallManager::joinParticipant(const std::string& sel_callID, const std::string& drag_callID)
+auto
+DBusCallManager::joinParticipant(const std::string& sel_callID, const std::string& drag_callID) -> decltype(DRing::joinParticipant(sel_callID, drag_callID))
{
- return ring_call_join_participant(sel_callID, drag_callID);
+ return DRing::joinParticipant(sel_callID, drag_callID);
}
-void DBusCallManager::createConfFromParticipantList(const std::vector< std::string >& participants)
+void
+DBusCallManager::createConfFromParticipantList(const std::vector< std::string >& participants)
{
- ring_call_create_conf_from_participant_list(participants);
+ DRing::createConfFromParticipantList(participants);
}
-bool DBusCallManager::isConferenceParticipant(const std::string& call_id)
+auto
+DBusCallManager::isConferenceParticipant(const std::string& call_id) -> decltype(DRing::isConferenceParticipant(call_id))
{
- return ring_call_is_conference_participant(call_id);
+ return DRing::isConferenceParticipant(call_id);
}
-bool DBusCallManager::addParticipant(const std::string& callID, const std::string& confID)
+auto
+DBusCallManager::addParticipant(const std::string& callID, const std::string& confID) -> decltype(DRing::addParticipant(callID, confID))
{
- return ring_call_add_participant(callID, confID);
+ return DRing::addParticipant(callID, confID);
}
-bool DBusCallManager::addMainParticipant(const std::string& confID)
+auto
+DBusCallManager::addMainParticipant(const std::string& confID) -> decltype(DRing::addMainParticipant(confID))
{
- return ring_call_add_main_participant(confID);
+ return DRing::addMainParticipant(confID);
}
-bool DBusCallManager::detachParticipant(const std::string& callID)
+auto
+DBusCallManager::detachParticipant(const std::string& callID) -> decltype(DRing::detachParticipant(callID))
{
- return ring_call_detach_participant(callID);
+ return DRing::detachParticipant(callID);
}
-bool DBusCallManager::joinConference(const std::string& sel_confID, const std::string& drag_confID)
+auto
+DBusCallManager::joinConference(const std::string& sel_confID, const std::string& drag_confID) -> decltype(DRing::joinConference(sel_confID, drag_confID))
{
- return ring_call_join_conference(sel_confID, drag_confID);
+ return DRing::joinConference(sel_confID, drag_confID);
}
-bool DBusCallManager::hangUpConference(const std::string& confID)
+auto
+DBusCallManager::hangUpConference(const std::string& confID) -> decltype(DRing::hangUpConference(confID))
{
- return ring_call_hang_up_conference(confID);
+ return DRing::hangUpConference(confID);
}
-bool DBusCallManager::holdConference(const std::string& confID)
+auto
+DBusCallManager::holdConference(const std::string& confID) -> decltype(DRing::holdConference(confID))
{
- return ring_call_hold_conference(confID);
+ return DRing::holdConference(confID);
}
-bool DBusCallManager::unholdConference(const std::string& confID)
+auto
+DBusCallManager::unholdConference(const std::string& confID) -> decltype(DRing::unholdConference(confID))
{
- return ring_call_unhold_conference(confID);
+ return DRing::unholdConference(confID);
}
-std::vector<std::string> DBusCallManager::getConferenceList()
+auto
+DBusCallManager::getConferenceList() -> decltype(DRing::getConferenceList())
{
- return ring_call_get_conference_list();
+ return DRing::getConferenceList();
}
-std::vector<std::string> DBusCallManager::getParticipantList(const std::string& confID)
+auto
+DBusCallManager::getParticipantList(const std::string& confID) -> decltype(DRing::getParticipantList(confID))
{
- return ring_call_get_participant_list(confID);
+ return DRing::getParticipantList(confID);
}
-std::vector<std::string> DBusCallManager::getDisplayNames(const std::string& confID)
+auto
+DBusCallManager::getDisplayNames(const std::string& confID) -> decltype(DRing::getDisplayNames(confID))
{
- return ring_call_get_display_names(confID);
+ return DRing::getDisplayNames(confID);
}
-std::string DBusCallManager::getConferenceId(const std::string& callID)
+auto
+DBusCallManager::getConferenceId(const std::string& callID) -> decltype(DRing::getConferenceId(callID))
{
- return ring_call_get_conference_id(callID);
+ return DRing::getConferenceId(callID);
}
-std::map<std::string, std::string> DBusCallManager::getConferenceDetails(const std::string& callID)
+auto
+DBusCallManager::getConferenceDetails(const std::string& callID) -> decltype(DRing::getConferenceDetails(callID))
{
- return ring_call_get_conference_details(callID);
+ return DRing::getConferenceDetails(callID);
}
-bool DBusCallManager::startRecordedFilePlayback(const std::string& filepath)
+auto
+DBusCallManager::startRecordedFilePlayback(const std::string& filepath) -> decltype(DRing::startRecordedFilePlayback(filepath))
{
- return ring_call_play_recorded_file(filepath);
+ return DRing::startRecordedFilePlayback(filepath);
}
-void DBusCallManager::stopRecordedFilePlayback(const std::string& filepath)
+void
+DBusCallManager::stopRecordedFilePlayback(const std::string& filepath)
{
- ring_call_stop_recorded_file(filepath);
+ DRing::stopRecordedFilePlayback(filepath);
}
-bool DBusCallManager::toggleRecording(const std::string& callID)
+auto
+DBusCallManager::toggleRecording(const std::string& callID) -> decltype(DRing::toggleRecording(callID))
{
- return ring_call_toggle_recording(callID);
+ return DRing::toggleRecording(callID);
}
-void DBusCallManager::setRecording(const std::string& callID)
+void
+DBusCallManager::setRecording(const std::string& callID)
{
- ring_call_set_recording(callID);
+ DRing::setRecording(callID);
}
-void DBusCallManager::recordPlaybackSeek(const double& value)
+void
+DBusCallManager::recordPlaybackSeek(const double& value)
{
- ring_call_record_playback_seek(value);
+ DRing::recordPlaybackSeek(value);
}
-bool DBusCallManager::getIsRecording(const std::string& callID)
+auto
+DBusCallManager::getIsRecording(const std::string& callID) -> decltype(DRing::getIsRecording(callID))
{
- return ring_call_is_recording(callID);
+ return DRing::getIsRecording(callID);
}
-std::string DBusCallManager::getCurrentAudioCodecName(const std::string& callID)
+auto
+DBusCallManager::getCurrentAudioCodecName(const std::string& callID) -> decltype(DRing::getCurrentAudioCodecName(callID))
{
- return ring_call_get_current_audio_codec_name(callID);
+ return DRing::getCurrentAudioCodecName(callID);
}
-void DBusCallManager::playDTMF(const std::string& key)
+void
+DBusCallManager::playDTMF(const std::string& key)
{
- ring_call_play_dtmf(key);
+ DRing::playDTMF(key);
}
-void DBusCallManager::startTone(const int32_t& start, const int32_t& type)
+void
+DBusCallManager::startTone(const int32_t& start, const int32_t& type)
{
- ring_call_start_tone(start, type);
+ DRing::startTone(start, type);
}
-void DBusCallManager::setSASVerified(const std::string& callID)
+void
+DBusCallManager::setSASVerified(const std::string& callID)
{
- ring_call_set_sas_verified(callID);
+ DRing::setSASVerified(callID);
}
-void DBusCallManager::resetSASVerified(const std::string& callID)
+void
+DBusCallManager::resetSASVerified(const std::string& callID)
{
- ring_call_reset_sas_verified(callID);
+ DRing::resetSASVerified(callID);
}
-void DBusCallManager::setConfirmGoClear(const std::string& callID)
+void
+DBusCallManager::setConfirmGoClear(const std::string& callID)
{
- ring_call_set_confirm_go_clear(callID);
+ DRing::setConfirmGoClear(callID);
}
-void DBusCallManager::requestGoClear(const std::string& callID)
+void
+DBusCallManager::requestGoClear(const std::string& callID)
{
- ring_call_request_go_clear(callID);
+ DRing::requestGoClear(callID);
}
-void DBusCallManager::acceptEnrollment(const std::string& callID, const bool& accepted)
+void
+DBusCallManager::acceptEnrollment(const std::string& callID, const bool& accepted)
{
- ring_call_accept_enrollment(callID, accepted);
+ DRing::acceptEnrollment(callID, accepted);
}
-void DBusCallManager::sendTextMessage(const std::string& callID, const std::string& message)
+void
+DBusCallManager::sendTextMessage(const std::string& callID, const std::string& message)
{
- ring_call_send_text_message(callID, message);
+ DRing::sendTextMessage(callID, message);
}
diff --git a/daemon/bin/dbus/dbuscallmanager.h b/daemon/bin/dbus/dbuscallmanager.h
index 89185e590b2dabc835d473f1f617f25bfcc075e8..0ef4dc42e942cf7b94d37550f42380cd93cdbb60 100644
--- a/daemon/bin/dbus/dbuscallmanager.h
+++ b/daemon/bin/dbus/dbuscallmanager.h
@@ -28,8 +28,8 @@
* as that of the covered work.
*/
-#ifndef __RING_CALLMANAGER_H__
-#define __RING_CALLMANAGER_H__
+#ifndef __RING_DBUSCALLMANAGER_H__
+#define __RING_DBUSCALLMANAGER_H__
#include <vector>
#include <map>
@@ -72,8 +72,8 @@ class DBusCallManager :
bool unhold(const std::string& callID);
bool transfer(const std::string& callID, const std::string& to);
bool attendedTransfer(const std::string& transferID, const std::string& targetID);
- std::map< std::string, std::string > getCallDetails(const std::string& callID);
- std::vector< std::string > getCallList();
+ std::map<std::string, std::string> getCallDetails(const std::string& callID);
+ std::vector<std::string> getCallList();
void removeConference(const std::string& conference_id);
bool joinParticipant(const std::string& sel_callID, const std::string& drag_callID);
void createConfFromParticipantList(const std::vector< std::string >& participants);
diff --git a/daemon/bin/dbus/dbusclient.cpp b/daemon/bin/dbus/dbusclient.cpp
index 777c76b0fe26932b3e8e7add2a57f8f7f190e3a9..704d79dacd0fc16e0ae22b94fe2b8fe31ca6dc90 100644
--- a/daemon/bin/dbus/dbusclient.cpp
+++ b/daemon/bin/dbus/dbusclient.cpp
@@ -1,6 +1,7 @@
/*
- * Copyright (C) 2014 Savoir-Faire Linux Inc.
+ * Copyright (C) 2014-2015 Savoir-Faire Linux Inc.
* Author: Philippe Proulx <philippe.proulx@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -31,200 +32,181 @@
#include <iostream>
#include <cstring>
#include <stdexcept>
-#include "dring.h"
#include "dbusclient.h"
#include "dbus_cpp.h"
#include "dbusinstance.h"
+
+#include "callmanager_interface.h"
#include "dbuscallmanager.h"
+
#include "dbusconfigurationmanager.h"
+#include "configurationmanager_interface.h"
+
#include "dbuspresencemanager.h"
+#include "presencemanager_interface.h"
#ifdef RING_VIDEO
#include "dbusvideomanager.h"
+#include "videomanager_interface.h"
#endif
-struct EventCallback : DBus::Callback_Base<void, DBus::DefaultTimeout&>
+class EventCallback :
+ public DBus::Callback_Base<void, DBus::DefaultTimeout&>
{
- EventCallback(const std::function<void()> &func) :
- callback_(func)
- {}
+ public:
+ EventCallback(const std::function<void()>&& func)
+ : callback_ {std::forward<const std::function<void()>>(func)}
+ {}
- void call(DBus::DefaultTimeout &) const
- {
- callback_();
- }
+ void call(DBus::DefaultTimeout&) const {
+ callback_();
+ }
-private:
- std::function<void()> callback_;
+ private:
+ const std::function<void()> callback_;
};
-DBusClient::DBusClient(int sflphFlags, bool persistent) :
- callManager_(nullptr)
- , configurationManager_(nullptr)
- , presenceManager_(nullptr)
- , instanceManager_(nullptr)
- , dispatcher_(new DBus::BusDispatcher)
-#ifdef RING_VIDEO
- , videoManager_(nullptr)
-#endif
- , timeout_(nullptr)
+DBusClient::DBusClient(int sflphFlags, bool persistent)
+ : dispatcher_(new DBus::BusDispatcher)
{
try {
DBus::_init_threading();
- DBus::default_dispatcher = dispatcher_;
+ DBus::default_dispatcher = dispatcher_.get();
// timeout and expired are deleted internally by dispatcher_'s
// destructor, so we must NOT delete them ourselves.
- timeout_ = new DBus::DefaultTimeout(10 /* ms */, true, dispatcher_);
- // Poll for SIP/IAX events
- timeout_->expired = new EventCallback(ring_poll_events);
+ timeout_.reset(new DBus::DefaultTimeout {10 /* ms */, true, dispatcher_.get()});
+ // Poll for Deamon events
+ timeout_->expired = new EventCallback {DRing::poll_events};
- DBus::Connection sessionConnection(DBus::Connection::SessionBus());
+ DBus::Connection sessionConnection {DBus::Connection::SessionBus()};
sessionConnection.request_name("cx.ring.Ring");
- callManager_ = new DBusCallManager(sessionConnection);
- configurationManager_ = new DBusConfigurationManager(sessionConnection);
-
- presenceManager_ = new DBusPresenceManager(sessionConnection);
+ callManager_.reset(new DBusCallManager {sessionConnection});
+ configurationManager_.reset(new DBusConfigurationManager {sessionConnection});
+ presenceManager_.reset(new DBusPresenceManager {sessionConnection});
DBusInstance::OnNoMoreClientFunc onNoMoreClientFunc;
+ if (!persistent)
+ onNoMoreClientFunc = [this] {this->exit();};
- if (!persistent) {
- onNoMoreClientFunc = [this] () {
- this->exit();
- };
- }
-
- instanceManager_ = new DBusInstance(sessionConnection, onNoMoreClientFunc);
+ instanceManager_.reset(new DBusInstance {sessionConnection, onNoMoreClientFunc});
#ifdef RING_VIDEO
- videoManager_ = new DBusVideoManager(sessionConnection);
+ videoManager_.reset(new DBusVideoManager {sessionConnection});
#endif
} catch (const DBus::Error &err) {
- throw std::runtime_error("cannot initialize DBus stuff");
+ throw std::runtime_error {"cannot initialize DBus stuff"};
}
- auto ret = initLibrary(sflphFlags);
-
- if (ret < 0) {
- throw std::runtime_error("cannot initialize libring");
- }
+ if (initLibrary(sflphFlags) < 0)
+ throw std::runtime_error {"cannot initialize libring"};
instanceManager_->started();
}
DBusClient::~DBusClient()
{
-#ifdef RING_VIDEO
- delete videoManager_;
-#endif
-
- delete instanceManager_;
-
- delete presenceManager_;
-
- delete configurationManager_;
- delete callManager_;
- delete dispatcher_;
+ dispatcher_.reset(); // force dispatcher reset first
}
int DBusClient::initLibrary(int sflphFlags)
{
using namespace std::placeholders;
- using std::bind;
-
- auto callM = callManager_; // just an alias
-
- // Call event handlers
- ring_call_ev_handlers callEvHandlers = {
- bind(&DBusCallManager::callStateChanged, callM, _1, _2),
- bind(&DBusCallManager::transferFailed, callM),
- bind(&DBusCallManager::transferSucceeded, callM),
- bind(&DBusCallManager::recordPlaybackStopped, callM, _1),
- bind(&DBusCallManager::voiceMailNotify, callM, _1, _2),
- bind(&DBusCallManager::incomingMessage, callM, _1, _2, _3),
- bind(&DBusCallManager::incomingCall, callM, _1, _2, _3),
- bind(&DBusCallManager::recordPlaybackFilepath, callM, _1, _2),
- bind(&DBusCallManager::conferenceCreated, callM, _1),
- bind(&DBusCallManager::conferenceChanged, callM, _1, _2),
- bind(&DBusCallManager::updatePlaybackScale, callM, _1, _2, _3),
- bind(&DBusCallManager::conferenceRemoved, callM, _1),
- bind(&DBusCallManager::newCallCreated, callM, _1, _2, _3),
- bind(&DBusCallManager::sipCallStateChanged, callM, _1, _2, _3),
- bind(&DBusCallManager::recordingStateChanged, callM, _1, _2),
- bind(&DBusCallManager::secureSdesOn, callM, _1),
- bind(&DBusCallManager::secureSdesOff, callM, _1),
- bind(&DBusCallManager::secureZrtpOn, callM, _1, _2),
- bind(&DBusCallManager::secureZrtpOff, callM, _1),
- bind(&DBusCallManager::showSAS, callM, _1, _2, _3),
- bind(&DBusCallManager::zrtpNotSuppOther, callM, _1),
- bind(&DBusCallManager::zrtpNegotiationFailed, callM, _1, _2, _3),
- bind(&DBusCallManager::onRtcpReportReceived, callM, _1, _2)
- };
-
- auto confM = configurationManager_; // just an alias
-
- // Configuration event handlers
- ring_config_ev_handlers configEvHandlers = {
- bind(&DBusConfigurationManager::volumeChanged, confM, _1, _2),
- bind(&DBusConfigurationManager::accountsChanged, confM),
- bind(&DBusConfigurationManager::historyChanged, confM),
- bind(&DBusConfigurationManager::stunStatusFailure, confM, _1),
- bind(&DBusConfigurationManager::registrationStateChanged, confM, _1, _2),
- bind(&DBusConfigurationManager::sipRegistrationStateChanged, confM, _1, _2, _3),
- bind(&DBusConfigurationManager::volatileAccountDetailsChanged, confM, _1, _2),
- bind(&DBusConfigurationManager::errorAlert, confM, _1),
- };
-
- auto presM = presenceManager_;
- // Presence event handlers
- ring_pres_ev_handlers presEvHandlers = {
- bind(&DBusPresenceManager::newServerSubscriptionRequest, presM, _1),
- bind(&DBusPresenceManager::serverError, presM, _1, _2, _3),
- bind(&DBusPresenceManager::newBuddyNotification, presM, _1, _2, _3, _4),
- bind(&DBusPresenceManager::subscriptionStateChanged, presM, _1, _2, _3)
- };
+ using std::bind;
+ using DRing::exportable_callback;
+ using DRing::CallSignal;
+ using DRing::ConfigurationSignal;
+ using DRing::PresenceSignal;
+ using DRing::VideoSignal;
+ using SharedCallback = std::shared_ptr<DRing::CallbackWrapperBase>;
+
+ auto callM = callManager_.get();
+ auto confM = configurationManager_.get();
+ auto presM = presenceManager_.get();
+ auto videoM = videoManager_.get();
+
+ const std::map<DRing::EventHandlerKey, std::map<std::string, SharedCallback>> evHandlers = {
+ { // Call event handlers
+ DRing::EventHandlerKey::CALL, {
+ exportable_callback<CallSignal::StateChange>(bind(&DBusCallManager::callStateChanged, callM, _1, _2)),
+ exportable_callback<CallSignal::TransferFailed>(bind(&DBusCallManager::transferFailed, callM)),
+ exportable_callback<CallSignal::TransferSucceeded>(bind(&DBusCallManager::transferSucceeded, callM)),
+ exportable_callback<CallSignal::RecordPlaybackStopped>(bind(&DBusCallManager::recordPlaybackStopped, callM, _1)),
+ exportable_callback<CallSignal::VoiceMailNotify>(bind(&DBusCallManager::voiceMailNotify, callM, _1, _2)),
+ exportable_callback<CallSignal::IncomingMessage>(bind(&DBusCallManager::incomingMessage, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::IncomingCall>(bind(&DBusCallManager::incomingCall, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::RecordPlaybackFilepath>(bind(&DBusCallManager::recordPlaybackFilepath, callM, _1, _2)),
+ exportable_callback<CallSignal::ConferenceCreated>(bind(&DBusCallManager::conferenceCreated, callM, _1)),
+ exportable_callback<CallSignal::ConferenceChanged>(bind(&DBusCallManager::conferenceChanged, callM, _1, _2)),
+ exportable_callback<CallSignal::UpdatePlaybackScale>(bind(&DBusCallManager::updatePlaybackScale, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::ConferenceRemoved>(bind(&DBusCallManager::conferenceRemoved, callM, _1)),
+ exportable_callback<CallSignal::NewCallCreated>(bind(&DBusCallManager::newCallCreated, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::SipCallStateChanged>(bind(&DBusCallManager::sipCallStateChanged, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::RecordingStateChanged>(bind(&DBusCallManager::recordingStateChanged, callM, _1, _2)),
+ exportable_callback<CallSignal::SecureSdesOn>(bind(&DBusCallManager::secureSdesOn, callM, _1)),
+ exportable_callback<CallSignal::SecureSdesOff>(bind(&DBusCallManager::secureSdesOff, callM, _1)),
+ exportable_callback<CallSignal::SecureZrtpOn>(bind(&DBusCallManager::secureZrtpOn, callM, _1, _2)),
+ exportable_callback<CallSignal::SecureZrtpOff>(bind(&DBusCallManager::secureZrtpOff, callM, _1)),
+ exportable_callback<CallSignal::ShowSAS>(bind(&DBusCallManager::showSAS, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::ZrtpNotSuppOther>(bind(&DBusCallManager::zrtpNotSuppOther, callM, _1)),
+ exportable_callback<CallSignal::ZrtpNegotiationFailed>(bind(&DBusCallManager::zrtpNegotiationFailed, callM, _1, _2, _3)),
+ exportable_callback<CallSignal::RtcpReportReceived>(bind(&DBusCallManager::onRtcpReportReceived, callM, _1, _2)),
+ }
+ },
+ { // Configuration event handlers
+ DRing::EventHandlerKey::CONFIG, {
+ exportable_callback<ConfigurationSignal::VolumeChanged>(bind(&DBusConfigurationManager::volumeChanged, confM, _1, _2)),
+ exportable_callback<ConfigurationSignal::AccountsChanged>(bind(&DBusConfigurationManager::accountsChanged, confM)),
+ exportable_callback<ConfigurationSignal::HistoryChanged>(bind(&DBusConfigurationManager::historyChanged, confM)),
+ exportable_callback<ConfigurationSignal::StunStatusFailed>(bind(&DBusConfigurationManager::stunStatusFailure, confM, _1)),
+ exportable_callback<ConfigurationSignal::RegistrationStateChanged>(bind(&DBusConfigurationManager::registrationStateChanged, confM, _1, _2)),
+ exportable_callback<ConfigurationSignal::SipRegistrationStateChanged>(bind(&DBusConfigurationManager::sipRegistrationStateChanged, confM, _1, _2, _3)),
+ exportable_callback<ConfigurationSignal::VolatileDetailsChanged>(bind(&DBusConfigurationManager::volatileAccountDetailsChanged, confM, _1, _2)),
+ exportable_callback<ConfigurationSignal::Error>(bind(&DBusConfigurationManager::errorAlert, confM, _1)),
+ }
+ },
+ { // Presence event handlers
+ DRing::EventHandlerKey::PRESENCE, {
+ exportable_callback<PresenceSignal::NewServerSubscriptionRequest>(bind(&DBusPresenceManager::newServerSubscriptionRequest, presM, _1)),
+ exportable_callback<PresenceSignal::ServerError>(bind(&DBusPresenceManager::serverError, presM, _1, _2, _3)),
+ exportable_callback<PresenceSignal::NewBuddyNotification>(bind(&DBusPresenceManager::newBuddyNotification, presM, _1, _2, _3, _4)),
+ exportable_callback<PresenceSignal::SubscriptionStateChanged>(bind(&DBusPresenceManager::subscriptionStateChanged, presM, _1, _2, _3)),
+ }
+ },
#ifdef RING_VIDEO
- auto videoM = videoManager_;
-
- // Video event handlers
- ring_video_ev_handlers videoEvHandlers = {
- bind(&DBusVideoManager::deviceEvent, videoM),
- bind(&DBusVideoManager::startedDecoding, videoM, _1, _2, _3, _4, _5),
- bind(&DBusVideoManager::stoppedDecoding, videoM, _1, _2, _3)
- };
-#endif // RING_VIDEO
-
- // All event handlers
- ring_ev_handlers evHandlers = {
- .call_ev_handlers = callEvHandlers,
- .config_ev_handlers = configEvHandlers,
- .pres_ev_handlers = presEvHandlers,
-#ifdef RING_VIDEO
- .video_ev_handlers = videoEvHandlers
-#endif // RING_VIDEO
+ { // Video event handlers
+ DRing::EventHandlerKey::VIDEO, {
+ exportable_callback<VideoSignal::DeviceEvent>(bind(&DBusVideoManager::deviceEvent, videoM)),
+ exportable_callback<VideoSignal::DecodingStarted>(bind(&DBusVideoManager::startedDecoding, videoM, _1, _2, _3, _4, _5)),
+ exportable_callback<VideoSignal::DecodingStopped>(bind(&DBusVideoManager::stoppedDecoding, videoM, _1, _2, _3)),
+ }
+ },
+#endif
};
// Initialize now
- return ring_init(&evHandlers, static_cast<ring_init_flag>(sflphFlags));
+ return (unsigned)DRing::init(evHandlers, static_cast<DRing::InitFlag>(sflphFlags));
}
-void DBusClient::finiLibrary()
+void
+DBusClient::finiLibrary() noexcept
{
- ring_fini();
+ DRing::fini();
}
-int DBusClient::event_loop()
+int
+DBusClient::event_loop() noexcept
{
try {
dispatcher_->enter();
- } catch (const DBus::Error &err) {
+ } catch (const DBus::Error& err) {
std::cerr << "quitting: " << err.name() << ": " << err.what() << std::endl;
return 1;
- } catch (const std::exception &err) {
+ } catch (const std::exception& err) {
std::cerr << "quitting: " << err.what() << std::endl;
return 1;
}
@@ -232,16 +214,17 @@ int DBusClient::event_loop()
return 0;
}
-int DBusClient::exit()
+int
+DBusClient::exit() noexcept
{
try {
dispatcher_->leave();
timeout_->expired = new EventCallback([] {});
finiLibrary();
- } catch (const DBus::Error &err) {
+ } catch (const DBus::Error& err) {
std::cerr << "quitting: " << err.name() << ": " << err.what() << std::endl;
return 1;
- } catch (const std::exception &err) {
+ } catch (const std::exception& err) {
std::cerr << "quitting: " << err.what() << std::endl;
return 1;
}
diff --git a/daemon/bin/dbus/dbusclient.h b/daemon/bin/dbus/dbusclient.h
index 0aedcae9c2a96d5ee70d8aef9052f20e48a388a9..21bd0e658e0a89ac9537905be71044f21baef41b 100644
--- a/daemon/bin/dbus/dbusclient.h
+++ b/daemon/bin/dbus/dbusclient.h
@@ -1,6 +1,7 @@
/*
* Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
* Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
+ * Author: Guillaume Roguez <guillaume.roguez@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
@@ -32,7 +33,6 @@
#define __DBUSCLIENT_H__
#include "dring.h"
-#include "noncopyable.h"
class DBusConfigurationManager;
class DBusCallManager;
@@ -54,26 +54,24 @@ class DBusClient {
DBusClient(int sflphFlags, bool persistent);
~DBusClient();
- int event_loop();
- int exit();
+ int event_loop() noexcept;
+ int exit() noexcept;
private:
- NON_COPYABLE(DBusClient);
-
int initLibrary(int sflphFlags);
- void finiLibrary();
+ void finiLibrary() noexcept;
- DBusCallManager* callManager_;
- DBusConfigurationManager* configurationManager_;
+ std::unique_ptr<DBus::BusDispatcher> dispatcher_;
+ std::unique_ptr<DBus::DefaultTimeout> timeout_;
- DBusPresenceManager* presenceManager_;
- DBusInstance* instanceManager_;
- DBus::BusDispatcher* dispatcher_;
+ std::unique_ptr<DBusCallManager> callManager_;
+ std::unique_ptr<DBusConfigurationManager> configurationManager_;
+ std::unique_ptr<DBusPresenceManager> presenceManager_;
+ std::unique_ptr<DBusInstance> instanceManager_;
#ifdef RING_VIDEO
- DBusVideoManager *videoManager_;
+ std::unique_ptr<DBusVideoManager> videoManager_;
#endif
- DBus::DefaultTimeout *timeout_;
};
#endif
diff --git a/daemon/bin/dbus/dbusconfigurationmanager.cpp b/daemon/bin/dbus/dbusconfigurationmanager.cpp
index 614c56a3b0b04a21a49f2b382a698fa6f2a89cec..9e755763edd4a4fea13d2c5977003ec65f9a1e39 100644
--- a/daemon/bin/dbus/dbusconfigurationmanager.cpp
+++ b/daemon/bin/dbus/dbusconfigurationmanager.cpp
@@ -27,342 +27,419 @@
* shall include the source code for the parts of OpenSSL used as well
* as that of the covered work.
*/
-#include <iostream>
-#include "dring.h"
#include "dbusconfigurationmanager.h"
+#include "configurationmanager_interface.h"
+
+#include "media/audio/audiolayer.h"
DBusConfigurationManager::DBusConfigurationManager(DBus::Connection& connection)
: DBus::ObjectAdaptor(connection, "/cx/ring/Ring/ConfigurationManager")
-{
-}
+{}
-std::map<std::string, std::string> DBusConfigurationManager::getAccountDetails(const std::string& accountID)
+auto
+DBusConfigurationManager::getAccountDetails(const std::string& accountID) -> decltype(DRing::getAccountDetails(accountID))
{
- return ring_config_get_account_details(accountID);
+ return DRing::getAccountDetails(accountID);
}
-std::map<std::string, std::string> DBusConfigurationManager::getVolatileAccountDetails(const std::string& accountID)
+auto
+DBusConfigurationManager::getVolatileAccountDetails(const std::string& accountID) -> decltype(DRing::getVolatileAccountDetails(accountID))
{
- return ring_config_get_volatile_account_details(accountID);
+ return DRing::getVolatileAccountDetails(accountID);
}
-void DBusConfigurationManager::setAccountDetails(const std::string& accountID, const std::map< std::string, std::string >& details)
+void
+DBusConfigurationManager::setAccountDetails(const std::string& accountID, const std::map<std::string, std::string>& details)
{
- ring_config_set_account_details(accountID, details);
+ DRing::setAccountDetails(accountID, details);
}
-std::map<std::string, std::string> DBusConfigurationManager::getAccountTemplate()
+auto
+DBusConfigurationManager::getAccountTemplate() -> decltype(DRing::getAccountTemplate())
{
- return ring_config_get_account_template();
+ return DRing::getAccountTemplate();
}
-std::string DBusConfigurationManager::addAccount(const std::map< std::string, std::string >& details)
+auto
+DBusConfigurationManager::addAccount(const std::map<std::string, std::string>& details) -> decltype(DRing::addAccount(details))
{
- return ring_config_add_account(details);
+ return DRing::addAccount(details);
}
-void DBusConfigurationManager::removeAccount(const std::string& accountID)
+void
+DBusConfigurationManager::removeAccount(const std::string& accountID)
{
- ring_config_remove_account(accountID);
+ DRing::removeAccount(accountID);
}
-std::vector< std::string > DBusConfigurationManager::getAccountList()
+auto
+DBusConfigurationManager::getAccountList() -> decltype(DRing::getAccountList())
{
- return ring_config_get_account_list();
+ return DRing::getAccountList();
}
-void DBusConfigurationManager::sendRegister(const std::string& accountID, const bool& enable)
+void
+DBusConfigurationManager::sendRegister(const std::string& accountID, const bool& enable)
{
- ring_config_send_register(accountID, enable);
+ DRing::sendRegister(accountID, enable);
}
-void DBusConfigurationManager::registerAllAccounts(void)
+void
+DBusConfigurationManager::registerAllAccounts(void)
{
- ring_config_register_all_accounts();
+ DRing::registerAllAccounts();
}
-std::map< std::string, std::string > DBusConfigurationManager::getTlsSettingsDefault()
+auto
+DBusConfigurationManager::getTlsDefaultSettings() -> decltype(DRing::getTlsDefaultSettings())
{
- return ring_config_get_tls_default_settings();
+ return DRing::getTlsDefaultSettings();
}
-std::vector< int32_t > DBusConfigurationManager::getAudioCodecList()
+auto
+DBusConfigurationManager::getAudioCodecList() -> decltype(DRing::getAudioCodecList())
{
- return ring_config_get_audio_codec_list();
+ return DRing::getAudioCodecList();
}
-std::vector< std::string > DBusConfigurationManager::getSupportedTlsMethod()
+auto
+DBusConfigurationManager::getSupportedTlsMethod() -> decltype(DRing::getSupportedTlsMethod())
{
- return ring_config_get_supported_tls_method();
+ return DRing::getSupportedTlsMethod();
}
-std::vector< std::string > DBusConfigurationManager::getSupportedCiphers(const std::string& accountID)
+auto
+DBusConfigurationManager::getSupportedCiphers(const std::string& accountID) -> decltype(DRing::getSupportedCiphers(accountID))
{
- return ring_config_get_supported_ciphers(accountID);
+ return DRing::getSupportedCiphers(accountID);
}
-std::vector< std::string > DBusConfigurationManager::getAudioCodecDetails(const int32_t& payload)
+auto
+DBusConfigurationManager::getAudioCodecDetails(const int32_t& payload) -> decltype(DRing::getAudioCodecDetails(payload))
{
- return ring_config_get_audio_codec_details(payload);
+ return DRing::getAudioCodecDetails(payload);
}
-std::vector< int32_t > DBusConfigurationManager::getActiveAudioCodecList(const std::string& accountID)
+auto
+DBusConfigurationManager::getActiveAudioCodecList(const std::string& accountID) -> decltype(DRing::getActiveAudioCodecList(accountID))
{
- return ring_config_get_active_audio_codec_list(accountID);
+ return DRing::getActiveAudioCodecList(accountID);
}
-void DBusConfigurationManager::setActiveAudioCodecList(const std::vector< std::string >& list, const std::string& accountID)
+void
+DBusConfigurationManager::setActiveAudioCodecList(const std::vector<std::string>& list, const std::string& accountID)
{
- ring_config_set_active_audio_codec_list(list, accountID);
+ DRing::setActiveAudioCodecList(list, accountID);
}
-std::vector< std::string > DBusConfigurationManager::getAudioPluginList()
+auto
+DBusConfigurationManager::getAudioPluginList() -> decltype(DRing::getAudioPluginList())
{
- return ring_config_get_audio_plugin_list();
+ return DRing::getAudioPluginList();
}
-void DBusConfigurationManager::setAudioPlugin(const std::string& audioPlugin)
+void
+DBusConfigurationManager::setAudioPlugin(const std::string& audioPlugin)
{
- ring_config_set_audio_plugin(audioPlugin);
+ DRing::setAudioPlugin(audioPlugin);
}
-std::vector< std::string > DBusConfigurationManager::getAudioOutputDeviceList()
+auto
+DBusConfigurationManager::getAudioOutputDeviceList() -> decltype(DRing::getAudioOutputDeviceList())
{
- return ring_config_get_audio_output_device_list();
+ return DRing::getAudioOutputDeviceList();
}
-void DBusConfigurationManager::setAudioOutputDevice(const int32_t& index)
+void
+DBusConfigurationManager::setAudioOutputDevice(const int32_t& index)
{
- ring_config_set_audio_output_device(index);
+ DRing::setAudioOutputDevice(index);
}
-void DBusConfigurationManager::setAudioInputDevice(const int32_t& index)
+void
+DBusConfigurationManager::setAudioInputDevice(const int32_t& index)
{
- ring_config_set_audio_input_device(index);
+ DRing::setAudioInputDevice(index);
}
-void DBusConfigurationManager::setAudioRingtoneDevice(const int32_t& index)
+void
+DBusConfigurationManager::setAudioRingtoneDevice(const int32_t& index)
{
- ring_config_set_audio_ringtone_device(index);
+ DRing::setAudioRingtoneDevice(index);
}
-std::vector< std::string > DBusConfigurationManager::getAudioInputDeviceList()
+auto
+DBusConfigurationManager::getAudioInputDeviceList() -> decltype(DRing::getAudioInputDeviceList())
{
- return ring_config_get_audio_input_device_list();
+ return DRing::getAudioInputDeviceList();
}
-std::vector< std::string > DBusConfigurationManager::getCurrentAudioDevicesIndex()
+auto
+DBusConfigurationManager::getCurrentAudioDevicesIndex() -> decltype(DRing::getCurrentAudioDevicesIndex())
{
- return ring_config_get_current_audio_devices_index();
+ return DRing::getCurrentAudioDevicesIndex();
}
-int32_t DBusConfigurationManager::getAudioInputDeviceIndex(const std::string& name)
+auto
+DBusConfigurationManager::getAudioInputDeviceIndex(const std::string& name) -> decltype(DRing::getAudioInputDeviceIndex(name))
{
- return ring_config_get_audio_input_device_index(name);
+ return DRing::getAudioInputDeviceIndex(name);
}
-int32_t DBusConfigurationManager::getAudioOutputDeviceIndex(const std::string& name)
+auto
+DBusConfigurationManager::getAudioOutputDeviceIndex(const std::string& name) -> decltype(DRing::getAudioOutputDeviceIndex(name))
{
- return ring_config_get_audio_output_device_index(name);
+ return DRing::getAudioOutputDeviceIndex(name);
}
-std::string DBusConfigurationManager::getCurrentAudioOutputPlugin()
+auto
+DBusConfigurationManager::getCurrentAudioOutputPlugin() -> decltype(DRing::getCurrentAudioOutputPlugin())
{
- return ring_config_get_current_audio_output_plugin();
+ return DRing::getCurrentAudioOutputPlugin();
}
-bool DBusConfigurationManager::getNoiseSuppressState()
+auto
+DBusConfigurationManager::getNoiseSuppressState() -> decltype(DRing::getNoiseSuppressState())
{
- return ring_config_get_noise_suppress_state();
+ return DRing::getNoiseSuppressState();
}
-void DBusConfigurationManager::setNoiseSuppressState(const bool& state)
+void
+DBusConfigurationManager::setNoiseSuppressState(const bool& state)
{
- ring_config_set_noise_suppress_state(state);
+ DRing::setNoiseSuppressState(state);
}
-bool DBusConfigurationManager::isAgcEnabled()
+auto
+DBusConfigurationManager::isAgcEnabled() -> decltype(DRing::isAgcEnabled())
{
- return ring_config_is_agc_enabled();
+ return DRing::isAgcEnabled();
}
-void DBusConfigurationManager::setAgcState(const bool& enabled)
+void
+DBusConfigurationManager::setAgcState(const bool& enabled)
{
- ring_config_enable_agc(enabled);
+ DRing::setAgcState(enabled);
}
-void DBusConfigurationManager::muteDtmf(const bool& mute)
+void
+DBusConfigurationManager::muteDtmf(const bool& mute)
{
- ring_config_mute_dtmf(mute);
+ DRing::muteDtmf(mute);
}
-bool DBusConfigurationManager::isDtmfMuted()
+auto
+DBusConfigurationManager::isDtmfMuted() -> decltype(DRing::isDtmfMuted())
{
- return ring_config_is_dtmf_muted();
+ return DRing::isDtmfMuted();
}
-bool DBusConfigurationManager::isCaptureMuted()
+auto
+DBusConfigurationManager::isCaptureMuted() -> decltype(DRing::isCaptureMuted())
{
- return ring_config_is_capture_muted();
+ return DRing::isCaptureMuted();
}
-void DBusConfigurationManager::muteCapture(const bool& mute)
+void
+DBusConfigurationManager::muteCapture(const bool& mute)
{
- ring_config_mute_capture(mute);
+ DRing::muteCapture(mute);
}
-bool DBusConfigurationManager::isPlaybackMuted()
+auto
+DBusConfigurationManager::isPlaybackMuted() -> decltype(DRing::isPlaybackMuted())
{
- return ring_config_is_playback_muted();
+ return DRing::isPlaybackMuted();
}
-void DBusConfigurationManager::mutePlayback(const bool& mute)
+void
+DBusConfigurationManager::mutePlayback(const bool& mute)
{
- ring_config_mute_playback(mute);
+ DRing::mutePlayback(mute);
}
-std::string DBusConfigurationManager::getAudioManager()
+auto
+DBusConfigurationManager::getAudioManager() -> decltype(DRing::getAudioManager())
{
- return ring_config_get_audio_manager();
+ return DRing::getAudioManager();
}
-bool DBusConfigurationManager::setAudioManager(const std::string& api)
+auto
+DBusConfigurationManager::setAudioManager(const std::string& api) -> decltype(DRing::setAudioManager(api))
{
- return ring_config_set_audio_manager(api);
+ return DRing::setAudioManager(api);
}
-std::vector<std::string> DBusConfigurationManager::getSupportedAudioManagers()
+//FIXME
+std::vector<std::string>
+DBusConfigurationManager::getSupportedAudioManagers()
{
- return ring_config_get_supported_audio_managers();
+ return {
+#if HAVE_ALSA
+ ALSA_API_STR,
+#endif
+#if HAVE_PULSE
+ PULSEAUDIO_API_STR,
+#endif
+#if HAVE_JACK
+ JACK_API_STR,
+#endif
+ };
}
-int32_t DBusConfigurationManager::isIax2Enabled()
+auto
+DBusConfigurationManager::isIax2Enabled() -> decltype(DRing::isIax2Enabled())
{
- return ring_config_is_iax2_enabled();
+ return DRing::isIax2Enabled();
}
-std::string DBusConfigurationManager::getRecordPath()
+auto
+DBusConfigurationManager::getRecordPath() -> decltype(DRing::getRecordPath())
{
- return ring_config_get_record_path();
+ return DRing::getRecordPath();
}
-void DBusConfigurationManager::setRecordPath(const std::string& recPath)
+void
+DBusConfigurationManager::setRecordPath(const std::string& recPath)
{
- ring_config_set_record_path(recPath);
+ DRing::setRecordPath(recPath);
}
-bool DBusConfigurationManager::getIsAlwaysRecording()
+auto
+DBusConfigurationManager::getIsAlwaysRecording() -> decltype(DRing::getIsAlwaysRecording())
{
- return ring_config_is_always_recording();
+ return DRing::getIsAlwaysRecording();
}
-void DBusConfigurationManager::setIsAlwaysRecording(const bool& rec)
+void
+DBusConfigurationManager::setIsAlwaysRecording(const bool& rec)
{
- ring_config_set_always_recording(rec);
+ DRing::setIsAlwaysRecording(rec);
}
-void DBusConfigurationManager::setHistoryLimit(const int32_t& days)
+void
+DBusConfigurationManager::setHistoryLimit(const int32_t& days)
{
- ring_config_set_history_limit(days);
+ DRing::setHistoryLimit(days);
}
-int32_t DBusConfigurationManager::getHistoryLimit()
+auto
+DBusConfigurationManager::getHistoryLimit() -> decltype(DRing::getHistoryLimit())
{
- return ring_config_get_history_limit();
+ return DRing::getHistoryLimit();
}
-void DBusConfigurationManager::clearHistory()
+void
+DBusConfigurationManager::clearHistory()
{
- ring_config_clear_history();
+ DRing::clearHistory();
}
-void DBusConfigurationManager::setAccountsOrder(const std::string& order)
+void
+DBusConfigurationManager::setAccountsOrder(const std::string& order)
{
- ring_config_set_accounts_order(order);
+ DRing::setAccountsOrder(order);
}
-std::map<std::string, std::string> DBusConfigurationManager::getHookSettings()
+auto
+DBusConfigurationManager::getHookSettings() -> decltype(DRing::getHookSettings())
{
- return ring_config_get_hook_settings();
+ return DRing::getHookSettings();
}
-void DBusConfigurationManager::setHookSettings(const std::map<std::string, std::string>& settings)
+void
+DBusConfigurationManager::setHookSettings(const std::map<std::string, std::string>& settings)
{
- ring_config_set_hook_settings(settings);
+ DRing::setHookSettings(settings);
}
-std::vector<std::map<std::string, std::string> > DBusConfigurationManager::getHistory()
+auto
+DBusConfigurationManager::getHistory() -> decltype(DRing::getHistory())
{
- return ring_config_get_history();
+ return DRing::getHistory();
}
-std::map<std::string, std::string> DBusConfigurationManager::getTlsSettings()
+auto
+DBusConfigurationManager::getTlsSettings() -> decltype(DRing::getTlsSettings())
{
- return ring_config_get_tls_settings();
+ return DRing::getTlsSettings();
}
-std::map<std::string, std::string> DBusConfigurationManager::validateCertificate(const std::string& accountId, const std::string& certificate, const std::string& privateKey)
+auto
+DBusConfigurationManager::validateCertificate(const std::string& accountId, const std::string& certificate, const std::string& privateKey) -> decltype(DRing::validateCertificate(accountId, certificate, privateKey))
{
- return ring_config_validate_certificate(accountId, certificate, privateKey);
+ return DRing::validateCertificate(accountId, certificate, privateKey);
}
-std::map<std::string, std::string> DBusConfigurationManager::getCertificateDetails(const std::string& certificate)
+auto
+DBusConfigurationManager::getCertificateDetails(const std::string& certificate) -> decltype(DRing::getCertificateDetails(certificate))
{
- return ring_config_get_certificate_details(certificate);
+ return DRing::getCertificateDetails(certificate);
}
-void DBusConfigurationManager::setTlsSettings(const std::map< std::string, std::string >& details)
+void
+DBusConfigurationManager::setTlsSettings(const std::map<std::string, std::string>& details)
{
- ring_config_set_tls_settings(details);
+ DRing::setTlsSettings(details);
}
-std::map< std::string, std::string > DBusConfigurationManager::getIp2IpDetails()
+auto
+DBusConfigurationManager::getIp2IpDetails() -> decltype(DRing::getIp2IpDetails())
{
- return ring_config_get_ip2ip_details();
+ return DRing::getIp2IpDetails();
}
-std::vector< std::map< std::string, std::string > > DBusConfigurationManager::getCredentials(const std::string& accountID)
+auto
+DBusConfigurationManager::getCredentials(const std::string& accountID) -> decltype(DRing::getCredentials(accountID))
{
- return ring_config_get_credentials(accountID);
+ return DRing::getCredentials(accountID);
}
-void DBusConfigurationManager::setCredentials(const std::string& accountID, const std::vector< std::map< std::string, std::string > >& details)
+void
+DBusConfigurationManager::setCredentials(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details)
{
- ring_config_set_credentials(accountID, details);
+ DRing::setCredentials(accountID, details);
}
-std::string DBusConfigurationManager::getAddrFromInterfaceName(const std::string& interface)
+auto
+DBusConfigurationManager::getAddrFromInterfaceName(const std::string& interface) -> decltype(DRing::getAddrFromInterfaceName(interface))
{
- return ring_config_get_addr_from_interface_name(interface);
+ return DRing::getAddrFromInterfaceName(interface);
}
-std::vector<std::string> DBusConfigurationManager::getAllIpInterface()
+auto
+DBusConfigurationManager::getAllIpInterface() -> decltype(DRing::getAllIpInterface())
{
- return ring_config_get_all_ip_interface();
+ return DRing::getAllIpInterface();
}
-std::vector<std::string> DBusConfigurationManager::getAllIpInterfaceByName()
+auto
+DBusConfigurationManager::getAllIpInterfaceByName() -> decltype(DRing::getAllIpInterfaceByName())
{
- return ring_config_get_all_ip_interface_by_name();
+ return DRing::getAllIpInterfaceByName();
}
-std::map<std::string, std::string> DBusConfigurationManager::getShortcuts()
+auto
+DBusConfigurationManager::getShortcuts() -> decltype(DRing::getShortcuts())
{
- return ring_config_get_shortcuts();
+ return DRing::getShortcuts();
}
-void DBusConfigurationManager::setShortcuts(const std::map<std::string, std::string> &shortcutsMap)
+void
+DBusConfigurationManager::setShortcuts(const std::map<std::string, std::string> &shortcutsMap)
{
- ring_config_set_shortcuts(shortcutsMap);
+ DRing::setShortcuts(shortcutsMap);
}
-void DBusConfigurationManager::setVolume(const std::string& device, const double& value)
+void
+DBusConfigurationManager::setVolume(const std::string& device, const double& value)
{
- ring_config_set_volume(device, value);
+ DRing::setVolume(device, value);
}
-double DBusConfigurationManager::getVolume(const std::string& device)
+auto
+DBusConfigurationManager::getVolume(const std::string& device) -> decltype(DRing::getVolume(device))
{
- return ring_config_get_volume(device);
+ return DRing::getVolume(device);
}
diff --git a/daemon/bin/dbus/dbusconfigurationmanager.h b/daemon/bin/dbus/dbusconfigurationmanager.h
index 39465eda05bec9905f9fbe3ba56c2f78e4360d44..940e6857966ffeef656691e66231be6349086ed4 100644
--- a/daemon/bin/dbus/dbusconfigurationmanager.h
+++ b/daemon/bin/dbus/dbusconfigurationmanager.h
@@ -56,8 +56,6 @@
#pragma GCC diagnostic warning "-Wunused-but-set-variable"
#endif
-#include <stdexcept>
-
class DBusConfigurationManager :
public cx::ring::Ring::ConfigurationManager_adaptor,
public DBus::IntrospectableAdaptor,
@@ -67,30 +65,30 @@ class DBusConfigurationManager :
DBusConfigurationManager(DBus::Connection& connection);
// Methods
- std::map< std::string, std::string > getAccountDetails(const std::string& accountID);
+ std::map<std::string, std::string> getAccountDetails(const std::string& accountID);
std::map<std::string, std::string> getVolatileAccountDetails(const std::string& accountID);
- void setAccountDetails(const std::string& accountID, const std::map< std::string, std::string >& details);
+ void setAccountDetails(const std::string& accountID, const std::map<std::string, std::string>& details);
std::map<std::string, std::string> getAccountTemplate();
- std::string addAccount(const std::map< std::string, std::string >& details);
+ std::string addAccount(const std::map<std::string, std::string>& details);
void removeAccount(const std::string& accoundID);
- std::vector< std::string > getAccountList();
+ std::vector<std::string> getAccountList();
void sendRegister(const std::string& accoundID, const bool& enable);
void registerAllAccounts(void);
- std::map< std::string, std::string > getTlsSettingsDefault();
- std::vector< std::string > getSupportedCiphers(const std::string& accountID);
- std::vector< int32_t > getAudioCodecList();
- std::vector< std::string > getSupportedTlsMethod();
- std::vector< std::string > getAudioCodecDetails(const int32_t& payload);
- std::vector< int32_t > getActiveAudioCodecList(const std::string& accountID);
- void setActiveAudioCodecList(const std::vector< std::string >& list, const std::string& accountID);
- std::vector< std::string > getAudioPluginList();
+ std::map<std::string, std::string> getTlsDefaultSettings();
+ std::vector<std::string> getSupportedCiphers(const std::string& accountID);
+ std::vector<int32_t> getAudioCodecList();
+ std::vector<std::string> getSupportedTlsMethod();
+ std::vector<std::string> getAudioCodecDetails(const int32_t& payload);
+ std::vector<int32_t> getActiveAudioCodecList(const std::string& accountID);
+ void setActiveAudioCodecList(const std::vector<std::string>& list, const std::string& accountID);
+ std::vector<std::string> getAudioPluginList();
void setAudioPlugin(const std::string& audioPlugin);
- std::vector< std::string > getAudioOutputDeviceList();
+ std::vector<std::string> getAudioOutputDeviceList();
void setAudioOutputDevice(const int32_t& index);
void setAudioInputDevice(const int32_t& index);
void setAudioRingtoneDevice(const int32_t& index);
- std::vector< std::string > getAudioInputDeviceList();
- std::vector< std::string > getCurrentAudioDevicesIndex();
+ std::vector<std::string> getAudioInputDeviceList();
+ std::vector<std::string> getCurrentAudioDevicesIndex();
int32_t getAudioInputDeviceIndex(const std::string& name);
int32_t getAudioOutputDeviceIndex(const std::string& name);
std::string getCurrentAudioOutputPlugin();
@@ -104,7 +102,6 @@ class DBusConfigurationManager :
void muteCapture(const bool& mute);
bool isPlaybackMuted();
void mutePlayback(const bool& mute);
- std::map<std::string, std::string> getRingtoneList();
std::string getAudioManager();
bool setAudioManager(const std::string& api);
std::vector<std::string> getSupportedAudioManagers();
@@ -119,12 +116,12 @@ class DBusConfigurationManager :
void setAccountsOrder(const std::string& order);
std::map<std::string, std::string> getHookSettings();
void setHookSettings(const std::map<std::string, std::string>& settings);
- std::vector<std::map<std::string, std::string> > getHistory();
+ std::vector<std::map<std::string, std::string>> getHistory();
std::map<std::string, std::string> getTlsSettings();
- void setTlsSettings(const std::map< std::string, std::string >& details);
- std::map< std::string, std::string > getIp2IpDetails();
- std::vector< std::map< std::string, std::string > > getCredentials(const std::string& accountID);
- void setCredentials(const std::string& accountID, const std::vector< std::map< std::string, std::string > >& details);
+ void setTlsSettings(const std::map<std::string, std::string>& details);
+ std::map<std::string, std::string> getIp2IpDetails();
+ std::vector<std::map<std::string, std::string>> getCredentials(const std::string& accountID);
+ void setCredentials(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details);
std::string getAddrFromInterfaceName(const std::string& interface);
std::vector<std::string> getAllIpInterface();
std::vector<std::string> getAllIpInterfaceByName();
@@ -132,8 +129,7 @@ class DBusConfigurationManager :
void setShortcuts(const std::map<std::string, std::string> &shortcutsMap);
void setVolume(const std::string& device, const double& value);
double getVolume(const std::string& device);
- std::map<std::string, std::string> validateCertificate(const std::string& accountId,
- const std::string& certificate, const std::string& privateKey);
+ std::map<std::string, std::string> validateCertificate(const std::string& accountId, const std::string& certificate, const std::string& privateKey);
std::map<std::string, std::string> getCertificateDetails(const std::string& certificate);
};
diff --git a/daemon/bin/dbus/dbusinstance.cpp b/daemon/bin/dbus/dbusinstance.cpp
index 87f81b0cdf87bb2af704927985774f5f2580979b..8aedbc307e6f384653fa3990579692b1b2924332 100644
--- a/daemon/bin/dbus/dbusinstance.cpp
+++ b/daemon/bin/dbus/dbusinstance.cpp
@@ -31,10 +31,10 @@
#include "dbusinstance.h"
DBusInstance::DBusInstance(DBus::Connection& connection,
- const OnNoMoreClientFunc& onNoMoreClientFunc) :
- DBus::ObjectAdaptor(connection, "/cx/ring/Ring/Instance"),
- onNoMoreClientFunc_(onNoMoreClientFunc),
- count_(0)
+ const OnNoMoreClientFunc& onNoMoreClientFunc)
+ : DBus::ObjectAdaptor(connection, "/cx/ring/Ring/Instance")
+ , onNoMoreClientFunc_(onNoMoreClientFunc)
+ , count_(0)
{}
void
diff --git a/daemon/bin/dbus/dbusinstance.h b/daemon/bin/dbus/dbusinstance.h
index 2ad3e14c76375708e7776d2181ebe7366ed9c65b..b410c21a7eabb0096e3a4a2b5b55f1aca0ce0dfd 100644
--- a/daemon/bin/dbus/dbusinstance.h
+++ b/daemon/bin/dbus/dbusinstance.h
@@ -53,9 +53,8 @@ class DBusInstance :
public DBus::ObjectAdaptor
{
public:
- typedef std::function<void ()> OnNoMoreClientFunc;
+ typedef std::function<void()> OnNoMoreClientFunc;
- public:
DBusInstance(DBus::Connection& connection,
const OnNoMoreClientFunc& onNoMoreClientFunc);
diff --git a/daemon/bin/dbus/dbuspresencemanager.cpp b/daemon/bin/dbus/dbuspresencemanager.cpp
index 14f3246830a61f5cbb63d26482f3421938072298..21a838e348883e39fb3f8b72ec13746d0aa68afa 100644
--- a/daemon/bin/dbus/dbuspresencemanager.cpp
+++ b/daemon/bin/dbus/dbuspresencemanager.cpp
@@ -27,36 +27,40 @@
* shall include the source code for the parts of OpenSSL used as well
* as that of the covered work.
*/
-#include "dring.h"
#include "dbuspresencemanager.h"
+#include "presencemanager_interface.h"
DBusPresenceManager::DBusPresenceManager(DBus::Connection& connection)
: DBus::ObjectAdaptor(connection, "/cx/ring/Ring/PresenceManager")
-{
-}
+{}
-void DBusPresenceManager::publish(const std::string& accountID, const bool& status, const std::string& note)
+void
+DBusPresenceManager::publish(const std::string& accountID, const bool& status, const std::string& note)
{
- ring_pres_publish(accountID, status, note);
+ DRing::publish(accountID, status, note);
}
-void DBusPresenceManager::answerServerRequest(const std::string& uri, const bool& flag)
+void
+DBusPresenceManager::answerServerRequest(const std::string& uri, const bool& flag)
{
- ring_pres_answer_server_request(uri, flag);
+ DRing::answerServerRequest(uri, flag);
}
-void DBusPresenceManager::subscribeBuddy(const std::string& accountID, const std::string& uri, const bool& flag)
+void
+DBusPresenceManager::subscribeBuddy(const std::string& accountID, const std::string& uri, const bool& flag)
{
- ring_pres_subscribe_buddy(accountID, uri, flag);
+ DRing::subscribeBuddy(accountID, uri, flag);
}
-std::vector<std::map<std::string, std::string> > DBusPresenceManager::getSubscriptions(const std::string& accountID)
+auto
+DBusPresenceManager::getSubscriptions(const std::string& accountID) -> decltype(DRing::getSubscriptions(accountID))
{
- return ring_pres_get_subscriptions(accountID);
+ return DRing::getSubscriptions(accountID);
}
-void DBusPresenceManager::setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris)
+void
+DBusPresenceManager::setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris)
{
- ring_pres_set_subscriptions(accountID, uris);
+ DRing::setSubscriptions(accountID, uris);
}
diff --git a/daemon/bin/dbus/dbuspresencemanager.h b/daemon/bin/dbus/dbuspresencemanager.h
index fce1283f48fee6fa88cc301f7728363f914637d8..9b9a8dbe6632bdc8e19b2fe4c881eb4442372c2b 100644
--- a/daemon/bin/dbus/dbuspresencemanager.h
+++ b/daemon/bin/dbus/dbuspresencemanager.h
@@ -53,8 +53,6 @@
#pragma GCC diagnostic warning "-Wunused-but-set-variable"
#endif
-#include <stdexcept>
-
class DBusPresenceManager :
public cx::ring::Ring::PresenceManager_adaptor,
public DBus::IntrospectableAdaptor,
@@ -67,7 +65,7 @@ class DBusPresenceManager :
void publish(const std::string& accountID, const bool& status, const std::string& note);
void answerServerRequest(const std::string& uri, const bool& flag);
void subscribeBuddy(const std::string& accountID, const std::string& uri, const bool& flag);
- std::vector<std::map<std::string, std::string> > getSubscriptions(const std::string& accountID);
+ std::vector<std::map<std::string, std::string>> getSubscriptions(const std::string& accountID);
void setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris);
};
diff --git a/daemon/bin/dbus/dbusvideomanager.cpp b/daemon/bin/dbus/dbusvideomanager.cpp
index 16596813b08ef3d50b591061db7c87f9c374f40d..e69e1e4a15c27f25fc51dd7eb00ee1ca29b46951 100644
--- a/daemon/bin/dbus/dbusvideomanager.cpp
+++ b/daemon/bin/dbus/dbusvideomanager.cpp
@@ -27,76 +27,90 @@
* shall include the source code for the parts of OpenSSL used as well
* as that of the covered work.
*/
-#include "dring.h"
#include "dbusvideomanager.h"
+#include "managerimpl.h"
+#include "manager.h"
+#include "client/videomanager.h"
DBusVideoManager::DBusVideoManager(DBus::Connection& connection)
: DBus::ObjectAdaptor(connection, "/cx/ring/Ring/VideoManager")
-{
-}
+{}
-std::vector<std::map<std::string, std::string>> DBusVideoManager::getCodecs(const std::string& accountID)
+auto
+DBusVideoManager::getCodecs(const std::string& accountID) -> decltype(DRing::getCodecs(accountID))
{
- return ring_video_get_codecs(accountID);
+ return DRing::getCodecs(accountID);
}
-void DBusVideoManager::setCodecs(const std::string& accountID, const std::vector<std::map<std::string, std::string> > &details)
+void
+DBusVideoManager::setCodecs(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details)
{
- ring_video_set_codecs(accountID, details);
+ DRing::setCodecs(accountID, details);
}
-std::vector<std::string> DBusVideoManager::getDeviceList()
+auto
+DBusVideoManager::getDeviceList() -> decltype(DRing::getDeviceList())
{
- return ring_video_get_device_list();
+ return DRing::getDeviceList();
}
-std::map<std::string, std::map<std::string, std::vector<std::string>>> DBusVideoManager::getCapabilities(const std::string& name)
+auto
+DBusVideoManager::getCapabilities(const std::string& name) -> decltype(DRing::getCapabilities(name))
{
- return ring_video_get_capabilities(name);
+ return DRing::getCapabilities(name);
}
-std::map<std::string, std::string> DBusVideoManager::getSettings(const std::string& name)
+auto
+DBusVideoManager::getSettings(const std::string& name) -> decltype(DRing::getSettings(name))
{
- return ring_video_get_settings(name);
+ return DRing::getSettings(name);
}
-void DBusVideoManager::applySettings(const std::string& name, const std::map<std::string, std::string>& settings)
+void
+DBusVideoManager::applySettings(const std::string& name, const std::map<std::string, std::string>& settings)
{
- ring_video_apply_settings(name, settings);
+ DRing::applySettings(name, settings);
}
-void DBusVideoManager::setDefaultDevice(const std::string &dev)
+void
+DBusVideoManager::setDefaultDevice(const std::string& dev)
{
- ring_video_set_default_device(dev);
+ DRing::setDefaultDevice(dev);
}
-std::string DBusVideoManager::getDefaultDevice()
+auto
+DBusVideoManager::getDefaultDevice() -> decltype(DRing::getDefaultDevice())
{
- return ring_video_get_default_device();
+ return DRing::getDefaultDevice();
}
-std::string DBusVideoManager::getCurrentCodecName(const std::string &callID)
+auto
+DBusVideoManager::getCurrentCodecName(const std::string& callID) -> decltype(DRing::getCurrentCodecName(callID))
{
- return ring_video_get_current_codec_name(callID);
+ return DRing::getCurrentCodecName(callID);
}
-void DBusVideoManager::startCamera()
+void
+DBusVideoManager::startCamera()
{
- ring_video_start_camera();
+ DRing::startCamera();
}
-void DBusVideoManager::stopCamera()
+void
+DBusVideoManager::stopCamera()
{
- ring_video_stop_camera();
+ DRing::stopCamera();
}
-bool DBusVideoManager::switchInput(const std::string& resource)
+auto
+DBusVideoManager::switchInput(const std::string& resource) -> decltype(DRing::switchInput(resource))
{
- return ring_video_switch_input(resource);
+ return DRing::switchInput(resource);
}
-bool DBusVideoManager::hasCameraStarted()
+auto
+DBusVideoManager::hasCameraStarted() -> decltype(DRing::hasCameraStarted())
{
- return ring_video_is_camera_started();
+ return DRing::hasCameraStarted();
}
diff --git a/daemon/bin/dbus/dbusvideomanager.h b/daemon/bin/dbus/dbusvideomanager.h
index 2d499c350b2e656468623b726ff1e9c1ef93633b..7d2d279804373f423b2143a15039f84e817c1ba0 100644
--- a/daemon/bin/dbus/dbusvideomanager.h
+++ b/daemon/bin/dbus/dbusvideomanager.h
@@ -52,26 +52,25 @@
#pragma GCC diagnostic warning "-Wunused-but-set-variable"
#endif
-#include <stdexcept>
-
class DBusVideoManager :
public cx::ring::Ring::VideoManager_adaptor,
public DBus::IntrospectableAdaptor,
public DBus::ObjectAdaptor
{
+
public:
DBusVideoManager(DBus::Connection& connection);
// Methods
std::vector<std::map<std::string, std::string>> getCodecs(const std::string& accountID);
- void setCodecs(const std::string& accountID, const std::vector<std::map<std::string, std::string> > &details);
+ void setCodecs(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details);
std::vector<std::string> getDeviceList();
std::map<std::string, std::map<std::string, std::vector<std::string>>> getCapabilities(const std::string& name);
std::map<std::string, std::string> getSettings(const std::string& name);
void applySettings(const std::string& name, const std::map<std::string, std::string>& settings);
- void setDefaultDevice(const std::string &dev);
+ void setDefaultDevice(const std::string& dev);
std::string getDefaultDevice();
- std::string getCurrentCodecName(const std::string &callID);
+ std::string getCurrentCodecName(const std::string& callID);
void startCamera();
void stopCamera();
bool switchInput(const std::string& resource);
diff --git a/daemon/bin/main.cpp b/daemon/bin/main.cpp
index 3a1c29bde1d665b46ebb2e42b662e8920a4e049a..83a40182c8bfc8a533e32a5072a43fab6b5bb57f 100644
--- a/daemon/bin/main.cpp
+++ b/daemon/bin/main.cpp
@@ -41,14 +41,17 @@
static int ringFlags = 0;
static std::unique_ptr<DBusClient> dbusClient;
-static void print_title()
+static void
+print_title()
{
- std::cout << "Ring Daemon " << ring_version() <<
- ", by Savoir-Faire Linux 2004-2015" << std::endl <<
- "http://www.sflphone.org/" << std::endl;
+ std::cout
+ << "Ring Daemon " << DRing::version()
+ << ", by Savoir-Faire Linux 2004-2015" << std::endl
+ << "http://www.sflphone.org/" << std::endl;
}
-static void print_usage()
+static void
+print_usage()
{
std::cout << std::endl <<
"-c, --console \t- Log in console (instead of syslog)" << std::endl <<
@@ -60,12 +63,9 @@ static void print_usage()
// Parse command line arguments, setting debug options or printing a help
// message accordingly.
// returns true if we should quit (i.e. help was printed), false otherwise
-static bool parse_args(int argc, char *argv[], bool &persistent)
+static bool
+parse_args(int argc, char *argv[], bool& persistent)
{
- int consoleFlag = false;
- int debugFlag = false;
- int helpFlag = false;
- int versionFlag = false;
static const struct option long_options[] = {
/* These options set a flag. */
{"debug", no_argument, NULL, 'd'},
@@ -76,16 +76,16 @@ static bool parse_args(int argc, char *argv[], bool &persistent)
{0, 0, 0, 0} /* Sentinel */
};
+ int consoleFlag = false;
+ int debugFlag = false;
+ int helpFlag = false;
+ int versionFlag = false;
+
while (true) {
/* getopt_long stores the option index here. */
int option_index = 0;
- int c = getopt_long(argc, argv, "dcphv", long_options, &option_index);
- /* Detect the end of the options. */
- if (c == -1)
- break;
-
- switch (c) {
+ switch (getopt_long(argc, argv, "dcphv", long_options, &option_index)) {
case 'd':
debugFlag = true;
break;
@@ -107,49 +107,51 @@ static bool parse_args(int argc, char *argv[], bool &persistent)
versionFlag = true;
break;
+ case -1: // end of the options
default:
break;
}
}
- bool quit = false;
if (helpFlag) {
print_usage();
- quit = true;
- } else if (versionFlag) {
+ return true;
+ }
+
+ if (versionFlag) {
// We've always print the title/version, so we can just exit
- quit = true;
- } else {
- if (consoleFlag) {
- ringFlags |= RING_FLAG_CONSOLE_LOG;
- }
- if (debugFlag) {
- ringFlags |= RING_FLAG_DEBUG;
- }
+ return true;
}
- return quit;
+
+ if (consoleFlag)
+ ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG;
+
+ if (debugFlag)
+ ringFlags |= DRing::DRING_FLAG_DEBUG;
+
+ return false;
}
-static int run()
+static int
+run()
{
- if (dbusClient) {
+ if (dbusClient)
return dbusClient->event_loop();
- }
-
return 1;
}
-static void interrupt()
+static void
+interrupt()
{
- if (dbusClient) {
+ if (dbusClient)
dbusClient->exit();
- }
}
-static void signal_handler(int code)
+static void
+signal_handler(int code)
{
std::cerr << "Caught signal " << strsignal(code)
- << ", terminating..." << std::endl;
+ << ", terminating..." << std::endl;
// Unset signal handlers
signal(SIGHUP, SIG_DFL);
@@ -159,13 +161,12 @@ static void signal_handler(int code)
interrupt();
}
-int main(int argc, char *argv [])
+int
+main(int argc, char *argv [])
{
- int ret;
-
// make a copy as we don't want to modify argv[0], copy it to a vector to
// guarantee that memory is correctly managed/exception safe
- std::string programName(argv[0]);
+ std::string programName {argv[0]};
std::vector<char> writable(programName.size() + 1);
std::copy(programName.begin(), programName.end(), writable.begin());
@@ -179,13 +180,12 @@ int main(int argc, char *argv [])
print_title();
bool persistent = false;
-
if (parse_args(argc, argv, persistent))
return 0;
// initialize client/library
try {
- dbusClient = std::unique_ptr<DBusClient>(new DBusClient(ringFlags, persistent));
+ dbusClient.reset(new DBusClient {ringFlags, persistent});
} catch (const std::exception& ex) {
std::cerr << "One does not simply initialize the DBus client: " << ex.what() << std::endl;
return 1;
@@ -201,10 +201,5 @@ int main(int argc, char *argv [])
std::cerr << "Warning: built with video support" << std::endl;
#endif
- ret = run();
-
- // terminate client/library
- dbusClient = nullptr;
-
- return ret;
+ return run();
}
diff --git a/daemon/bin/osxmain.cpp b/daemon/bin/osxmain.cpp
index f147f806036f8977dc1666592d57f480ac8a4fef..e0a24d966c077ada0280390aaa7f05fb2a95f8c3 100644
--- a/daemon/bin/osxmain.cpp
+++ b/daemon/bin/osxmain.cpp
@@ -37,18 +37,26 @@
#include <string>
#include "dring.h"
+#include "callmanager_interface.h"
+#include "configurationmanager_interface.h"
+#include "presencemanager_interface.h"
+#ifdef RING_VIDEO
+#include "videomanager_interface.h"
+#endif
#include "fileutils.h"
-static int sflphFlags = 0;
+static int ringFlags = 0;
-static void print_title()
+static void
+print_title()
{
- std::cout << "Ring Daemon " << ring_version() <<
- ", by Savoir-Faire Linux 2004-2015" << std::endl <<
- "http://www.sflphone.org/" << std::endl;
+ std::cout << "Ring Daemon " << DRing::version()
+ << ", by Savoir-Faire Linux 2004-2015" << std::endl
+ << "http://www.sflphone.org/" << std::endl;
}
-static void print_usage()
+static void
+print_usage()
{
std::cout << std::endl <<
"-c, --console \t- Log in console (instead of syslog)" << std::endl <<
@@ -60,12 +68,9 @@ static void print_usage()
// Parse command line arguments, setting debug options or printing a help
// message accordingly.
// returns true if we should quit (i.e. help was printed), false otherwise
-static bool parse_args(int argc, char *argv[], bool &persistent)
+static bool
+parse_args(int argc, char *argv[], bool& persistent)
{
- int consoleFlag = false;
- int debugFlag = false;
- int helpFlag = false;
- int versionFlag = false;
static const struct option long_options[] = {
/* These options set a flag. */
{"debug", no_argument, NULL, 'd'},
@@ -76,16 +81,16 @@ static bool parse_args(int argc, char *argv[], bool &persistent)
{0, 0, 0, 0} /* Sentinel */
};
+ int consoleFlag = false;
+ int debugFlag = false;
+ int helpFlag = false;
+ int versionFlag = false;
+
while (true) {
/* getopt_long stores the option index here. */
int option_index = 0;
- int c = getopt_long(argc, argv, "dcphv", long_options, &option_index);
-
- /* Detect the end of the options. */
- if (c == -1)
- break;
- switch (c) {
+ switch (getopt_long(argc, argv, "dcphv", long_options, &option_index)) {
case 'd':
debugFlag = true;
break;
@@ -107,86 +112,63 @@ static bool parse_args(int argc, char *argv[], bool &persistent)
versionFlag = true;
break;
+ case -1: // end of the options
default:
break;
}
}
- bool quit = false;
if (helpFlag) {
print_usage();
- quit = true;
- } else if (versionFlag) {
+ return true;
+ }
+
+ if (versionFlag) {
// We've always print the title/version, so we can just exit
- quit = true;
- } else {
- if (consoleFlag) {
- sflphFlags |= RING_FLAG_CONSOLE_LOG;
- }
- if (debugFlag) {
- sflphFlags |= RING_FLAG_DEBUG;
- }
+ return true;
}
- return quit;
-}
-void myOnIncomingCall(const std::string& acc_id, const std::string& call_id, const std::string& from)
-{
- std::cout << std::endl << "INCOMING CALL!" << std::endl <<
- "Account: " << acc_id <<
- ", Id: " << call_id <<
- ", From: " << from << std::endl << std::endl;
-
- ring_call_accept(call_id);
- ring_call_set_recording(call_id);
- //ring_call_join_participant(call_id, "patate");
-}
+ if (consoleFlag)
+ ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG;
-static int osxTests()
-{
- ring_ev_handlers evHandlers = {
- .call_ev_handlers = {
- .on_incoming_call = myOnIncomingCall
- },
- .config_ev_handlers = {},
- .pres_ev_handlers = {}
-#ifdef RING_VIDEO
- ,.video_ev_handlers = {}
-#endif
- };
+ if (debugFlag)
+ ringFlags |= DRing::DRING_FLAG_DEBUG;
- ring_init(&evHandlers, static_cast<ring_init_flag>(sflphFlags));
+ return false;
+}
- //ring_call_play_dtmf("0");
- //sleep(1);
- //ring_call_play_dtmf("1");
- //sleep(1);
+static int
+osxTests()
+{
+ using SharedCallback = std::shared_ptr<DRing::CallbackWrapperBase>;
- //ring_call_place("IP2IP", "patate", "127.0.0.1");
- //ring_call_set_recording("patate");
+ DRing::init(std::map<DRing::EventHandlerKey, std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>>>(),
+ static_cast<DRing::InitFlag>(ringFlags));
while (true) {
- ring_poll_events();
+ DRing::poll_events();
sleep(1);
}
- ring_fini();
+ DRing::fini();
}
-static int run()
+static int
+run()
{
osxTests();
return 0;
}
-static void interrupt()
-{
-}
+static void
+interrupt()
+{}
-static void signal_handler(int code)
+static void
+signal_handler(int code)
{
std::cerr << "Caught signal " << strsignal(code)
- << ", terminating..." << std::endl;
+ << ", terminating..." << std::endl;
// Unset signal handlers
signal(SIGHUP, SIG_DFL);
@@ -196,13 +178,12 @@ static void signal_handler(int code)
interrupt();
}
-int main(int argc, char *argv [])
+int
+main(int argc, char *argv [])
{
- int ret;
-
// make a copy as we don't want to modify argv[0], copy it to a vector to
// guarantee that memory is correctly managed/exception safe
- std::string programName(argv[0]);
+ std::string programName {argv[0]};
std::vector<char> writable(programName.size() + 1);
std::copy(programName.begin(), programName.end(), writable.begin());
@@ -216,7 +197,6 @@ int main(int argc, char *argv [])
print_title();
bool persistent = false;
-
if (parse_args(argc, argv, persistent))
return 0;
@@ -230,7 +210,5 @@ int main(int argc, char *argv [])
std::cerr << "Warning: built with video support" << std::endl;
#endif
- ret = run();
-
- return ret;
+ return run();
}
diff --git a/daemon/src/Makefile.am b/daemon/src/Makefile.am
index f32f2ad5c52be427175b243e2af4f5f8246d66b2..5f1fe1d81253f64038228950545d5753d43c7d0c 100644
--- a/daemon/src/Makefile.am
+++ b/daemon/src/Makefile.am
@@ -137,4 +137,12 @@ libring_la_SOURCES = conference.cpp \
nobase_include_HEADERS= dring/dring.h \
dring/security_const.h \
+ dring/callmanager_interface.h \
+ dring/configurationmanager_interface.h \
+ dring/presencemanager_interface.h \
dring/account_const.h
+
+if RING_VIDEO
+nobase_include_HEADERS+= \
+ dring/videomanager_interface.h
+endif
diff --git a/daemon/src/account.cpp b/daemon/src/account.cpp
index fa8ce0b2a7eef4f3ec0b5d9539842c5beff08eeb..28c9cdfb26a15e06a5c1d2456ffd34dd1eb09dc3 100644
--- a/daemon/src/account.cpp
+++ b/daemon/src/account.cpp
@@ -47,7 +47,7 @@
#include "logger.h"
#include "manager.h"
-#include "client/configurationmanager.h"
+#include "client/signal.h"
#include "account_schema.h"
#include "string_utils.h"
#include "config/yamlparser.h"
@@ -150,9 +150,11 @@ void Account::setRegistrationState(RegistrationState state)
if (state != registrationState_) {
registrationState_ = state;
// Notify the client
- ConfigurationManager *c(Manager::instance().getConfigurationManager());
- c->registrationStateChanged(accountID_, static_cast<int32_t>(registrationState_));
- c->volatileAccountDetailsChanged(accountID_, getVolatileAccountDetails());
+ emitSignal<DRing::ConfigurationSignal::RegistrationStateChanged>(accountID_,
+ static_cast<int32_t>(registrationState_));
+
+ emitSignal<DRing::ConfigurationSignal::VolatileDetailsChanged>(accountID_,
+ getVolatileAccountDetails());
}
}
diff --git a/daemon/src/client/Makefile.am b/daemon/src/client/Makefile.am
index 988530745dda41220e77cf109ac8a4e58a30572a..6a6c0cbec8db17c03ea0af53e3b265781c2b789c 100644
--- a/daemon/src/client/Makefile.am
+++ b/daemon/src/client/Makefile.am
@@ -2,23 +2,25 @@ include $(top_srcdir)/globals.mak
noinst_LTLIBRARIES = libclient.la
-noinst_HEADERS = callmanager.h \
- configurationmanager.h
+noinst_HEADERS = \
+ signal.h
PRESENCE_SRC = presencemanager.cpp
-noinst_HEADERS += presencemanager.h
if RING_VIDEO
VIDEO_SRC = videomanager.cpp
noinst_HEADERS += videomanager.h
endif
-libclient_la_SOURCES = callmanager.cpp \
- configurationmanager.cpp \
- $(PRESENCE_SRC) \
- $(VIDEO_SRC)
+libclient_la_SOURCES = \
+ signal.cpp \
+ callmanager.cpp \
+ configurationmanager.cpp \
+ $(PRESENCE_SRC) \
+ $(VIDEO_SRC)
-libclient_la_CXXFLAGS = -I./ \
- -I../ \
- -DPREFIX=\"$(prefix)\" \
- -DPROGSHAREDIR=\"${datadir}/ring\"
+libclient_la_CXXFLAGS = \
+ -I./ \
+ -I../ \
+ -DPREFIX=\"$(prefix)\" \
+ -DPROGSHAREDIR=\"${datadir}/ring\"
diff --git a/daemon/src/client/callmanager.cpp b/daemon/src/client/callmanager.cpp
index 51f1956644709574606e63a6bf9ede1cbe4e4ea9..6fa6b321ba4feb83332ffbedd88d230882aaf86e 100644
--- a/daemon/src/client/callmanager.cpp
+++ b/daemon/src/client/callmanager.cpp
@@ -2,6 +2,7 @@
* Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
* Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
* Author: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -31,9 +32,9 @@
#include <vector>
#include <cstring>
-#include "callmanager.h"
-#include "libav_utils.h"
+#include "callmanager_interface.h"
#include "call_factory.h"
+#include "client/signal.h"
#include "sip/sipcall.h"
#include "sip/sipvoiplink.h"
@@ -42,453 +43,301 @@
#include "logger.h"
#include "manager.h"
-namespace ring {
+namespace DRing {
-CallManager::CallManager()
-{
- libav_utils::sfl_avcodec_init();
-}
-
-void CallManager::registerEvHandlers(struct ring_call_ev_handlers* evHandlers)
-{
- evHandlers_ = *evHandlers;
+void
+registerCallHandlers(const std::map<std::string,
+ std::shared_ptr<CallbackWrapperBase>>& handlers)
+{
+ auto& handlers_ = ring::getSignalHandlers();
+ for (auto& item : handlers) {
+ auto iter = handlers_.find(item.first);
+ if (iter == handlers_.end()) {
+ RING_ERR("Signal %s not supported", item.first.c_str());
+ continue;
+ }
+
+ iter->second = std::move(item.second);
+ }
}
-bool CallManager::placeCall(const std::string& accountID,
- const std::string& callID,
- const std::string& to)
+bool
+placeCall(const std::string& accountID,
+ const std::string& callID,
+ const std::string& to)
{
// Check if a destination number is available
if (to.empty()) {
RING_DBG("No number entered - Call stopped");
return false;
} else {
- return Manager::instance().outgoingCall(accountID, callID, to);
+ return ring::Manager::instance().outgoingCall(accountID, callID, to);
}
}
bool
-CallManager::refuse(const std::string& callID)
+refuse(const std::string& callID)
{
- return Manager::instance().refuseCall(callID);
+ return ring::Manager::instance().refuseCall(callID);
}
bool
-CallManager::accept(const std::string& callID)
+accept(const std::string& callID)
{
- return Manager::instance().answerCall(callID);
+ return ring::Manager::instance().answerCall(callID);
}
bool
-CallManager::hangUp(const std::string& callID)
+hangUp(const std::string& callID)
{
- return Manager::instance().hangupCall(callID);
+ return ring::Manager::instance().hangupCall(callID);
}
bool
-CallManager::hangUpConference(const std::string& confID)
+hangUpConference(const std::string& confID)
{
- return Manager::instance().hangupConference(confID);
+ return ring::Manager::instance().hangupConference(confID);
}
bool
-CallManager::hold(const std::string& callID)
+hold(const std::string& callID)
{
- return Manager::instance().onHoldCall(callID);
+ return ring::Manager::instance().onHoldCall(callID);
}
bool
-CallManager::unhold(const std::string& callID)
+unhold(const std::string& callID)
{
- return Manager::instance().offHoldCall(callID);
+ return ring::Manager::instance().offHoldCall(callID);
}
bool
-CallManager::transfer(const std::string& callID, const std::string& to)
+transfer(const std::string& callID, const std::string& to)
{
- return Manager::instance().transferCall(callID, to);
+ return ring::Manager::instance().transferCall(callID, to);
}
bool
-CallManager::attendedTransfer(const std::string& transferID, const std::string& targetID)
+attendedTransfer(const std::string& transferID, const std::string& targetID)
{
- return Manager::instance().attendedTransfer(transferID, targetID);
+ return ring::Manager::instance().attendedTransfer(transferID, targetID);
}
bool
-CallManager::joinParticipant(const std::string& sel_callID,
+joinParticipant(const std::string& sel_callID,
const std::string& drag_callID)
{
- return Manager::instance().joinParticipant(sel_callID, drag_callID);
+ return ring::Manager::instance().joinParticipant(sel_callID, drag_callID);
}
void
-CallManager::createConfFromParticipantList(const std::vector<std::string>& participants)
+createConfFromParticipantList(const std::vector<std::string>& participants)
{
- Manager::instance().createConfFromParticipantList(participants);
+ ring::Manager::instance().createConfFromParticipantList(participants);
}
bool
-CallManager::isConferenceParticipant(const std::string& callID)
+isConferenceParticipant(const std::string& callID)
{
- return Manager::instance().isConferenceParticipant(callID);
+ return ring::Manager::instance().isConferenceParticipant(callID);
}
void
-CallManager::removeConference(const std::string& conference_id)
+removeConference(const std::string& conference_id)
{
- Manager::instance().removeConference(conference_id);
+ ring::Manager::instance().removeConference(conference_id);
}
bool
-CallManager::addParticipant(const std::string& callID, const std::string& confID)
+addParticipant(const std::string& callID, const std::string& confID)
{
- return Manager::instance().addParticipant(callID, confID);
+ return ring::Manager::instance().addParticipant(callID, confID);
}
bool
-CallManager::addMainParticipant(const std::string& confID)
+addMainParticipant(const std::string& confID)
{
- return Manager::instance().addMainParticipant(confID);
+ return ring::Manager::instance().addMainParticipant(confID);
}
bool
-CallManager::detachParticipant(const std::string& callID)
+detachParticipant(const std::string& callID)
{
- return Manager::instance().detachParticipant(callID);
+ return ring::Manager::instance().detachParticipant(callID);
}
bool
-CallManager::joinConference(const std::string& sel_confID, const std::string& drag_confID)
+joinConference(const std::string& sel_confID, const std::string& drag_confID)
{
- return Manager::instance().joinConference(sel_confID, drag_confID);
+ return ring::Manager::instance().joinConference(sel_confID, drag_confID);
}
bool
-CallManager::holdConference(const std::string& confID)
+holdConference(const std::string& confID)
{
- return Manager::instance().holdConference(confID);
+ return ring::Manager::instance().holdConference(confID);
}
bool
-CallManager::unholdConference(const std::string& confID)
+unholdConference(const std::string& confID)
{
- return Manager::instance().unHoldConference(confID);
+ return ring::Manager::instance().unHoldConference(confID);
}
std::map<std::string, std::string>
-CallManager::getConferenceDetails(const std::string& callID)
+getConferenceDetails(const std::string& callID)
{
- return Manager::instance().getConferenceDetails(callID);
+ return ring::Manager::instance().getConferenceDetails(callID);
}
std::vector<std::string>
-CallManager::getConferenceList()
+getConferenceList()
{
- return Manager::instance().getConferenceList();
+ return ring::Manager::instance().getConferenceList();
}
std::vector<std::string>
-CallManager::getParticipantList(const std::string& confID)
+getParticipantList(const std::string& confID)
{
- return Manager::instance().getParticipantList(confID);
+ return ring::Manager::instance().getParticipantList(confID);
}
std::vector<std::string>
-CallManager::getDisplayNames(const std::string& confID)
+getDisplayNames(const std::string& confID)
{
- return Manager::instance().getDisplayNames(confID);
+ return ring::Manager::instance().getDisplayNames(confID);
}
std::string
-CallManager::getConferenceId(const std::string& callID)
+getConferenceId(const std::string& callID)
{
- return Manager::instance().getConferenceId(callID);
+ return ring::Manager::instance().getConferenceId(callID);
}
bool
-CallManager::startRecordedFilePlayback(const std::string& filepath)
+startRecordedFilePlayback(const std::string& filepath)
{
- return Manager::instance().startRecordedFilePlayback(filepath);
+ return ring::Manager::instance().startRecordedFilePlayback(filepath);
}
void
-CallManager::stopRecordedFilePlayback(const std::string& filepath)
+stopRecordedFilePlayback(const std::string& filepath)
{
- Manager::instance().stopRecordedFilePlayback(filepath);
+ ring::Manager::instance().stopRecordedFilePlayback(filepath);
}
bool
-CallManager::toggleRecording(const std::string& callID)
+toggleRecording(const std::string& callID)
{
- return Manager::instance().toggleRecordingCall(callID);
+ return ring::Manager::instance().toggleRecordingCall(callID);
}
void
-CallManager::setRecording(const std::string& callID)
+setRecording(const std::string& callID)
{
toggleRecording(callID);
}
void
-CallManager::recordPlaybackSeek(double value)
+recordPlaybackSeek(double value)
{
- Manager::instance().recordingPlaybackSeek(value);
+ ring::Manager::instance().recordingPlaybackSeek(value);
}
bool
-CallManager::getIsRecording(const std::string& callID)
+getIsRecording(const std::string& callID)
{
- return Manager::instance().isRecording(callID);
+ return ring::Manager::instance().isRecording(callID);
}
-std::string CallManager::getCurrentAudioCodecName(const std::string& /*callID*/)
+std::string
+getCurrentAudioCodecName(const std::string&)
{
RING_WARN("Deprecated");
return "";
}
std::map<std::string, std::string>
-CallManager::getCallDetails(const std::string& callID)
+getCallDetails(const std::string& callID)
{
- return Manager::instance().getCallDetails(callID);
+ return ring::Manager::instance().getCallDetails(callID);
}
std::vector<std::string>
-CallManager::getCallList()
+getCallList()
{
- return Manager::instance().getCallList();
+ return ring::Manager::instance().getCallList();
}
void
-CallManager::playDTMF(const std::string& key)
+playDTMF(const std::string& key)
{
auto code = key.data()[0];
- Manager::instance().playDtmf(code);
+ ring::Manager::instance().playDtmf(code);
- if (auto current_call = Manager::instance().getCurrentCall())
+ if (auto current_call = ring::Manager::instance().getCurrentCall())
current_call->carryingDTMFdigits(code);
}
void
-CallManager::startTone(int32_t start, int32_t type)
+startTone(int32_t start, int32_t type)
{
if (start) {
if (type == 0)
- Manager::instance().playTone();
+ ring::Manager::instance().playTone();
else
- Manager::instance().playToneWithMessage();
+ ring::Manager::instance().playToneWithMessage();
} else
- Manager::instance().stopTone();
+ ring::Manager::instance().stopTone();
}
void
-CallManager::setSASVerified(const std::string& /*callID*/)
+setSASVerified(const std::string& /*callID*/)
{
RING_ERR("ZRTP not supported");
}
void
-CallManager::resetSASVerified(const std::string& /*callID*/)
+resetSASVerified(const std::string& /*callID*/)
{
RING_ERR("ZRTP not supported");
}
void
-CallManager::setConfirmGoClear(const std::string& /*callID*/)
+setConfirmGoClear(const std::string& /*callID*/)
{
RING_ERR("ZRTP not supported");
}
void
-CallManager::requestGoClear(const std::string& /*callID*/)
+requestGoClear(const std::string& /*callID*/)
{
RING_ERR("ZRTP not supported");
}
void
-CallManager::acceptEnrollment(const std::string& /*callID*/, bool /*accepted*/)
+acceptEnrollment(const std::string& /*callID*/, bool /*accepted*/)
{
RING_ERR("ZRTP not supported");
}
-void CallManager::sendTextMessage(const std::string& callID, const std::string& message, const std::string& from)
+void
+sendTextMessage(const std::string& callID, const std::string& message, const std::string& from)
{
#if HAVE_INSTANT_MESSAGING
- Manager::instance().sendTextMessage(callID, message, from);
+ ring::Manager::instance().sendTextMessage(callID, message, from);
#endif
}
void
-CallManager::sendTextMessage(const std::string& callID, const std::string& message)
+sendTextMessage(const std::string& callID, const std::string& message)
{
#if HAVE_INSTANT_MESSAGING
- if (!Manager::instance().sendTextMessage(callID, message, "Me"))
+ if (!ring::Manager::instance().sendTextMessage(callID, message, "Me"))
throw CallManagerException();
#else
RING_ERR("Could not send \"%s\" text message to %s since SFLphone daemon does not support it, please recompile with instant messaging support", message.c_str(), callID.c_str());
#endif
}
-void CallManager::callStateChanged(const std::string& callID, const std::string& state)
-{
- if (evHandlers_.on_state_change) {
- evHandlers_.on_state_change(callID, state);
- }
-}
-
-void CallManager::transferFailed()
-{
- if (evHandlers_.on_transfer_fail) {
- evHandlers_.on_transfer_fail();
- }
-}
-
-void CallManager::transferSucceeded()
-{
- if (evHandlers_.on_transfer_success) {
- evHandlers_.on_transfer_success();
- }
-}
-
-void CallManager::recordPlaybackStopped(const std::string& path)
-{
- if (evHandlers_.on_record_playback_stopped) {
- evHandlers_.on_record_playback_stopped(path);
- }
-}
-
-void CallManager::voiceMailNotify(const std::string& callID, int32_t nd_msg)
-{
- if (evHandlers_.on_voice_mail_notify) {
- evHandlers_.on_voice_mail_notify(callID, nd_msg);
- }
-}
-
-void CallManager::incomingMessage(const std::string& ID, const std::string& from, const std::string& msg)
-{
- if (evHandlers_.on_incoming_message) {
- evHandlers_.on_incoming_message(ID, from, msg);
- }
-}
-
-void CallManager::incomingCall(const std::string& accountID, const std::string& callID, const std::string& from)
-{
- if (evHandlers_.on_incoming_call) {
- evHandlers_.on_incoming_call(accountID, callID, from);
- }
-}
-
-void CallManager::recordPlaybackFilepath(const std::string& id, const std::string& filename)
-{
- if (evHandlers_.on_record_playback_filepath) {
- evHandlers_.on_record_playback_filepath(id, filename);
- }
-}
-
-void CallManager::conferenceCreated(const std::string& confID)
-{
- if (evHandlers_.on_conference_created) {
- evHandlers_.on_conference_created(confID);
- }
-}
-
-void CallManager::conferenceChanged(const std::string& confID, const std::string& state)
-{
- if (evHandlers_.on_conference_changed) {
- evHandlers_.on_conference_changed(confID, state);
- }
-}
-
-void CallManager::updatePlaybackScale(const std::string& filepath, int32_t position, int32_t scale)
-{
- if (evHandlers_.on_update_playback_scale) {
- evHandlers_.on_update_playback_scale(filepath, position, scale);
- }
-}
-
-void CallManager::conferenceRemoved(const std::string& confID)
-{
- if (evHandlers_.on_conference_remove) {
- evHandlers_.on_conference_remove(confID);
- }
-}
-
-void CallManager::newCallCreated(const std::string& accountID, const std::string& callID, const std::string& to)
-{
- if (evHandlers_.on_new_call) {
- evHandlers_.on_new_call(accountID, callID, to);
- }
-}
-
-void CallManager::sipCallStateChanged(const std::string& callID, const std::string& state, int32_t code)
-{
- if (evHandlers_.on_sip_call_state_change) {
- evHandlers_.on_sip_call_state_change(callID, state, code);
- }
-}
-
-void CallManager::recordingStateChanged(const std::string& callID, bool state)
-{
- if (evHandlers_.on_record_state_change) {
- evHandlers_.on_record_state_change(callID, state);
- }
-}
-
-void CallManager::secureSdesOn(const std::string& callID)
-{
- if (evHandlers_.on_secure_sdes_on) {
- evHandlers_.on_secure_sdes_on(callID);
- }
-}
-
-void CallManager::secureSdesOff(const std::string& callID)
-{
- if (evHandlers_.on_secure_sdes_off) {
- evHandlers_.on_secure_sdes_off(callID);
- }
-}
-
-void CallManager::secureZrtpOn(const std::string& callID, const std::string& cipher)
-{
- if (evHandlers_.on_secure_zrtp_on) {
- evHandlers_.on_secure_zrtp_on(callID, cipher);
- }
-}
-
-void CallManager::secureZrtpOff(const std::string& callID)
-{
- if (evHandlers_.on_secure_zrtp_off) {
- evHandlers_.on_secure_zrtp_off(callID);
- }
-}
-
-void CallManager::showSAS(const std::string& callID, const std::string& sas, bool verified)
-{
- if (evHandlers_.on_show_sas) {
- evHandlers_.on_show_sas(callID, sas, verified);
- }
-}
-
-void CallManager::zrtpNotSuppOther(const std::string& callID)
-{
- if (evHandlers_.on_zrtp_not_supp_other) {
- evHandlers_.on_zrtp_not_supp_other(callID);
- }
-}
-
-void CallManager::zrtpNegotiationFailed(const std::string& callID, const std::string& reason, const std::string& severity)
-{
- if (evHandlers_.on_zrtp_negotiation_fail) {
- evHandlers_.on_zrtp_negotiation_fail(callID, reason, severity);
- }
-}
-
-void CallManager::onRtcpReportReceived(const std::string& callID, const std::map<std::string, int>& stats)
-{
- if (evHandlers_.on_rtcp_receive_report) {
- evHandlers_.on_rtcp_receive_report(callID, stats);
- }
-}
-
-} // namespace ring
+} // namespace DRing
diff --git a/daemon/src/client/callmanager.h b/daemon/src/client/callmanager.h
deleted file mode 100644
index 6686a14a74fde3dc81c697cca9c2be81f29202d1..0000000000000000000000000000000000000000
--- a/daemon/src/client/callmanager.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
- * Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
- */
-
-#ifndef __RING_CALLMANAGER_H__
-#define __RING_CALLMANAGER_H__
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdexcept>
-#include <map>
-#include <vector>
-#include <string>
-
-#include "dring.h"
-
-namespace ring {
-
-class AudioZrtpSession;
-
-class CallManagerException: public std::runtime_error {
- public:
- CallManagerException(const std::string& str = "") :
- std::runtime_error("A CallManagerException occured: " + str) {}
-};
-
-class CallManager
-{
- public:
- CallManager();
- void registerEvHandlers(struct ring_call_ev_handlers* evHandlers);
-
- // Methods
- public:
- /* Call related methods */
- bool placeCall(const std::string& accountID, const std::string& callID, const std::string& to);
-
- bool refuse(const std::string& callID);
- bool accept(const std::string& callID);
- bool hangUp(const std::string& callID);
- bool hold(const std::string& callID);
- bool unhold(const std::string& callID);
- bool transfer(const std::string& callID, const std::string& to);
- bool attendedTransfer(const std::string& transferID, const std::string& targetID);
- std::map< std::string, std::string > getCallDetails(const std::string& callID);
- std::vector< std::string > getCallList();
-
- /* Conference related methods */
- void removeConference(const std::string& conference_id);
- bool joinParticipant(const std::string& sel_callID, const std::string& drag_callID);
- void createConfFromParticipantList(const std::vector< std::string >& participants);
- bool isConferenceParticipant(const std::string& call_id);
- bool addParticipant(const std::string& callID, const std::string& confID);
- bool addMainParticipant(const std::string& confID);
- bool detachParticipant(const std::string& callID);
- bool joinConference(const std::string& sel_confID, const std::string& drag_confID);
- bool hangUpConference(const std::string& confID);
- bool holdConference(const std::string& confID);
- bool unholdConference(const std::string& confID);
- std::vector<std::string> getConferenceList();
- std::vector<std::string> getParticipantList(const std::string& confID);
- std::vector<std::string> getDisplayNames(const std::string& confID);
- std::string getConferenceId(const std::string& callID);
- std::map<std::string, std::string> getConferenceDetails(const std::string& callID);
-
- /* File Playback methods */
- bool startRecordedFilePlayback(const std::string& filepath);
- void stopRecordedFilePlayback(const std::string& filepath);
-
- /* General audio methods */
- bool toggleRecording(const std::string& callID);
- /* DEPRECATED */
- void setRecording(const std::string& callID);
-
- void recordPlaybackSeek(double value);
- bool getIsRecording(const std::string& callID);
- std::string getCurrentAudioCodecName(const std::string& callID);
- void playDTMF(const std::string& key);
- void startTone(int32_t start, int32_t type);
-
- /* Security related methods */
- void setSASVerified(const std::string& callID);
- void resetSASVerified(const std::string& callID);
- void setConfirmGoClear(const std::string& callID);
- void requestGoClear(const std::string& callID);
- void acceptEnrollment(const std::string& callID, bool accepted);
-
- /* Instant messaging */
- void sendTextMessage(const std::string& callID, const std::string& message);
- void sendTextMessage(const std::string& callID, const std::string& message, const std::string& from);
-
- // Signals
- public:
- void callStateChanged(const std::string& callID, const std::string& state);
-
- void transferFailed();
-
- void transferSucceeded();
-
- void recordPlaybackStopped(const std::string& path);
-
- void voiceMailNotify(const std::string& callID, int32_t nd_msg);
-
- void incomingMessage(const std::string& ID, const std::string& from, const std::string& msg);
-
- void incomingCall(const std::string& accountID, const std::string& callID, const std::string& from);
-
- void recordPlaybackFilepath(const std::string& id, const std::string& filename);
-
- void conferenceCreated(const std::string& confID);
-
- void conferenceChanged(const std::string& confID,const std::string& state);
-
- void updatePlaybackScale(const std::string&, int32_t, int32_t);
- void conferenceRemoved(const std::string&);
- void newCallCreated(const std::string&, const std::string&, const std::string&);
- void sipCallStateChanged(const std::string&, const std::string&, int32_t);
- void recordingStateChanged(const std::string& callID, bool state);
- void secureSdesOn(const std::string& arg);
- void secureSdesOff(const std::string& arg);
-
- void secureZrtpOn(const std::string& callID, const std::string& cipher);
- void secureZrtpOff(const std::string& callID);
- void showSAS(const std::string& callID, const std::string& sas, bool verified);
- void zrtpNotSuppOther(const std::string& callID);
- void zrtpNegotiationFailed(const std::string& callID, const std::string& arg2, const std::string& arg3);
-
- void onRtcpReportReceived(const std::string& callID, const std::map<std::string, int>& stats);
-
- private:
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
- // Event handlers; needed by the library API
- ring_call_ev_handlers evHandlers_{};
-#pragma GCC diagnostic warning "-Wmissing-field-initializers"
-};
-
-} // namespace ring
-
-#endif//CALLMANAGER_H
diff --git a/daemon/src/client/configurationmanager.cpp b/daemon/src/client/configurationmanager.cpp
index c3fb0f46d0aa3a46c5a2dd18f8a10a449ee2c744..410a8f6c379b37bdb708a5bdb509340a3837d4a2 100644
--- a/daemon/src/client/configurationmanager.cpp
+++ b/daemon/src/client/configurationmanager.cpp
@@ -3,6 +3,7 @@
* Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
* Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
* Author: Guillaume Carmel-Archambault <guillaume.carmel-archambault@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -34,7 +35,7 @@
#include "config.h"
#endif
-#include "configurationmanager.h"
+#include "configurationmanager_interface.h"
#include "account_schema.h"
#include "manager.h"
#if HAVE_TLS && HAVE_DHT
@@ -46,6 +47,7 @@
#include "sip/sipaccount.h"
#include "security_const.h"
#include "audio/audiolayer.h"
+#include "client/signal.h"
#include <dirent.h>
@@ -53,124 +55,127 @@
#include <cstring>
#include <sstream>
-#define CODECS_NOT_LOADED 0x1000 /** Codecs not found */
+namespace DRing {
-namespace ring {
+constexpr unsigned CODECS_NOT_LOADED = 0x1000; /** Codecs not found */
-void ConfigurationManager::registerEvHandlers(struct ring_config_ev_handlers* evHandlers)
+using ring::SIPAccount;
+using ring::TlsValidator;
+using ring::Account;
+using ring::DeviceType;
+using ring::HookPreference;
+
+void
+registerConfHandlers(const std::map<std::string,
+ std::shared_ptr<CallbackWrapperBase>>& handlers)
{
- evHandlers_ = *evHandlers;
+ auto& handlers_ = ring::getSignalHandlers();
+ for (auto& item : handlers) {
+ auto iter = handlers_.find(item.first);
+ if (iter == handlers_.end()) {
+ RING_ERR("Signal %s not supported", item.first.c_str());
+ continue;
+ }
+
+ iter->second = std::move(item.second);
+ }
}
-std::map<std::string, std::string> ConfigurationManager::getIp2IpDetails()
+std::map<std::string, std::string>
+getIp2IpDetails()
{
- const auto account = Manager::instance().getIP2IPAccount();
- const auto sipaccount = static_cast<SIPAccount *>(account.get());
-
- if (!sipaccount) {
- RING_ERR("Could not find IP2IP account");
- return std::map<std::string, std::string>();
- } else
+ auto account = ring::Manager::instance().getIP2IPAccount();
+ if (auto sipaccount = static_cast<SIPAccount*>(account.get()))
return sipaccount->getIp2IpDetails();
+ RING_ERR("Could not find IP2IP account");
+ return std::map<std::string, std::string>();
}
-std::map<std::string, std::string> ConfigurationManager::getAccountDetails(
- const std::string& accountID)
+std::map<std::string, std::string>
+getAccountDetails(const std::string& accountID)
{
- return Manager::instance().getAccountDetails(accountID);
+ return ring::Manager::instance().getAccountDetails(accountID);
}
-std::map<std::string, std::string> ConfigurationManager::getVolatileAccountDetails(
- const std::string& accountID)
+std::map<std::string, std::string>
+getVolatileAccountDetails(const std::string& accountID)
{
- return Manager::instance().getVolatileAccountDetails(accountID);
+ return ring::Manager::instance().getVolatileAccountDetails(accountID);
}
std::map<std::string, std::string>
-ConfigurationManager::getTlsSettingsDefault()
+getTlsDefaultSettings()
{
std::stringstream portstr;
portstr << DEFAULT_SIP_TLS_PORT;
- std::map<std::string, std::string> tlsSettingsDefault;
- tlsSettingsDefault[Conf::CONFIG_TLS_LISTENER_PORT] = portstr.str();
- tlsSettingsDefault[Conf::CONFIG_TLS_CA_LIST_FILE] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_CERTIFICATE_FILE] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_PRIVATE_KEY_FILE] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_PASSWORD] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_METHOD] = "TLSv1";
- tlsSettingsDefault[Conf::CONFIG_TLS_CIPHERS] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_SERVER_NAME] = "";
- tlsSettingsDefault[Conf::CONFIG_TLS_VERIFY_SERVER] = "true";
- tlsSettingsDefault[Conf::CONFIG_TLS_VERIFY_CLIENT] = "true";
- tlsSettingsDefault[Conf::CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE] = "true";
- tlsSettingsDefault[Conf::CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC] = "2";
-
- return tlsSettingsDefault;
+ return {
+ {ring::Conf::CONFIG_TLS_LISTENER_PORT, portstr.str()},
+ {ring::Conf::CONFIG_TLS_CA_LIST_FILE, ""},
+ {ring::Conf::CONFIG_TLS_CERTIFICATE_FILE, ""},
+ {ring::Conf::CONFIG_TLS_PRIVATE_KEY_FILE, ""},
+ {ring::Conf::CONFIG_TLS_PASSWORD, ""},
+ {ring::Conf::CONFIG_TLS_METHOD, "TLSv1"},
+ {ring::Conf::CONFIG_TLS_CIPHERS, ""},
+ {ring::Conf::CONFIG_TLS_SERVER_NAME, ""},
+ {ring::Conf::CONFIG_TLS_VERIFY_SERVER, "true"},
+ {ring::Conf::CONFIG_TLS_VERIFY_CLIENT, "true"},
+ {ring::Conf::CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE, "true"},
+ {ring::Conf::CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC, "2"}
+ };
}
-std::map<std::string, std::string> ConfigurationManager::getTlsSettings()
+std::map<std::string, std::string>
+getTlsSettings()
{
- std::map<std::string, std::string> tlsSettings;
-
- const auto account = Manager::instance().getIP2IPAccount();
- const auto sipaccount = static_cast<SIPAccount *>(account.get());
-
- if (!sipaccount)
- return tlsSettings;
-
- return sipaccount->getTlsSettings();
+ auto account = ring::Manager::instance().getIP2IPAccount();
+ if (auto sipaccount = static_cast<SIPAccount*>(account.get()))
+ return sipaccount->getTlsSettings();
+ RING_ERR("Could not find IP2IP account");
+ return std::map<std::string, std::string>();
}
-void ConfigurationManager::setTlsSettings(const std::map<std::string, std::string>& details)
+void
+setTlsSettings(const std::map<std::string, std::string>& details)
{
- const auto account = Manager::instance().getIP2IPAccount();
- const auto sipaccount = static_cast<SIPAccount *>(account.get());
-
- if (!sipaccount) {
- RING_DBG("No valid account in set TLS settings");
- return;
+ auto account = ring::Manager::instance().getIP2IPAccount();
+ if (auto sipaccount = static_cast<SIPAccount*>(account.get())) {
+ sipaccount->setTlsSettings(details);
+ ring::Manager::instance().saveConfig();
+ ring::emitSignal<ConfigurationSignal::AccountsChanged>();
}
- sipaccount->setTlsSettings(details);
-
- Manager::instance().saveConfig();
-
- // Update account details to the client side
- accountsChanged();
+ RING_DBG("No valid account in set TLS settings");
+ return;
}
-std::map<std::string, std::string> ConfigurationManager::validateCertificate(const std::string&,
- const std::string& certificate,
- const std::string& privateKey)
+std::map<std::string, std::string>
+validateCertificate(const std::string&,
+ const std::string& certificate,
+ const std::string& privateKey)
{
#if HAVE_TLS && HAVE_DHT
try {
- TlsValidator validator(certificate,privateKey);
- return validator.getSerializedChecks();
- }
- catch(const std::runtime_error& e) {
- std::map<std::string, std::string> res;
+ return TlsValidator{certificate, privateKey}.getSerializedChecks();
+ } catch(const std::runtime_error& e) {
RING_WARN("Certificate loading failed");
- res[DRing::Certificate::ChecksNames::EXIST] = DRing::Certificate::CheckValuesNames::FAILED;
- return res;
+ return {{Certificate::ChecksNames::EXIST, Certificate::CheckValuesNames::FAILED}};
}
#else
RING_WARN("TLS not supported");
- return std::map<std::string, std::string>();
+ return {};
#endif
}
-std::map<std::string, std::string> ConfigurationManager::getCertificateDetails(const std::string& certificate)
+std::map<std::string, std::string>
+getCertificateDetails(const std::string& certificate)
{
#if HAVE_TLS && HAVE_DHT
try {
- TlsValidator validator(certificate,"");
- return validator.getSerializedDetails();
- }
- catch(const std::runtime_error& e) {
+ return TlsValidator{certificate,""}.getSerializedDetails();
+ } catch(const std::runtime_error& e) {
RING_WARN("Certificate loading failed");
}
#else
@@ -179,474 +184,415 @@ std::map<std::string, std::string> ConfigurationManager::getCertificateDetails(c
return std::map<std::string, std::string>();
}
-void ConfigurationManager::setAccountDetails(const std::string& accountID, const std::map<std::string, std::string>& details)
+void
+setAccountDetails(const std::string& accountID, const std::map<std::string, std::string>& details)
{
- Manager::instance().setAccountDetails(accountID, details);
+ ring::Manager::instance().setAccountDetails(accountID, details);
}
-void ConfigurationManager::sendRegister(const std::string& accountID, bool enable)
+void
+sendRegister(const std::string& accountID, bool enable)
{
- Manager::instance().sendRegister(accountID, enable);
+ ring::Manager::instance().sendRegister(accountID, enable);
}
-void ConfigurationManager::registerAllAccounts()
+void
+registerAllAccounts()
{
- Manager::instance().registerAccounts();
+ ring::Manager::instance().registerAccounts();
}
///This function is used as a base for new accounts for clients that support it
-std::map<std::string, std::string> ConfigurationManager::getAccountTemplate()
+std::map<std::string, std::string>
+getAccountTemplate()
{
- SIPAccount dummy("dummy", false);
- return dummy.getAccountDetails();
+ return SIPAccount{"dummy", false}.getAccountDetails();
}
-std::string ConfigurationManager::addAccount(const std::map<std::string, std::string>& details)
+std::string
+addAccount(const std::map<std::string, std::string>& details)
{
- return Manager::instance().addAccount(details);
+ return ring::Manager::instance().addAccount(details);
}
-void ConfigurationManager::removeAccount(const std::string& accountID)
+void
+removeAccount(const std::string& accountID)
{
- return Manager::instance().removeAccount(accountID);
+ return ring::Manager::instance().removeAccount(accountID);
}
-std::vector<std::string> ConfigurationManager::getAccountList()
+std::vector<std::string>
+getAccountList()
{
- return Manager::instance().getAccountList();
+ return ring::Manager::instance().getAccountList();
}
/**
* Send the list of all codecs loaded to the client through DBus.
* Can stay global, as only the active codecs will be set per accounts
*/
-std::vector<int32_t> ConfigurationManager::getAudioCodecList()
+std::vector<int32_t>
+getAudioCodecList()
{
- std::vector<int32_t> list(Manager::instance().audioCodecFactory.getCodecList());
-
+ std::vector<int32_t> list {ring::Manager::instance().audioCodecFactory.getCodecList()};
if (list.empty())
- errorAlert(CODECS_NOT_LOADED);
-
+ ring::emitSignal<ConfigurationSignal::Error>(CODECS_NOT_LOADED);
return list;
}
-std::vector<std::string> ConfigurationManager::getSupportedTlsMethod()
+std::vector<std::string>
+getSupportedTlsMethod()
{
- std::vector<std::string> method;
- method.push_back("Default");
- method.push_back("TLSv1");
- method.push_back("SSLv3");
- method.push_back("SSLv23");
- return method;
+ return {"Default", "TLSv1", "SSLv3", "SSLv23"};
}
-std::vector<std::string> ConfigurationManager::getSupportedCiphers(const std::string& accountID) const
+std::vector<std::string>
+getSupportedCiphers(const std::string& accountID)
{
#if HAVE_TLS
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
- if (sipaccount) {
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID))
return sipaccount->getSupportedCiphers();
- } else {
- RING_ERR("SIP account %s doesn't exist", accountID.c_str());
-#else
- {
+ RING_ERR("SIP account %s doesn't exist", accountID.c_str());
#endif
- return {};
- }
-
+ return {};
}
-std::vector<std::string> ConfigurationManager::getAudioCodecDetails(int32_t payload)
+std::vector<std::string>
+getAudioCodecDetails(int32_t payload)
{
- std::vector<std::string> result(Manager::instance().audioCodecFactory.getCodecSpecifications(payload));
-
+ std::vector<std::string> result {ring::Manager::instance().audioCodecFactory.getCodecSpecifications(payload)};
if (result.empty())
- errorAlert(CODECS_NOT_LOADED);
-
+ ring::emitSignal<ConfigurationSignal::Error>(CODECS_NOT_LOADED);
return result;
}
-std::vector<int32_t> ConfigurationManager::getActiveAudioCodecList(const std::string& accountID)
+std::vector<int32_t>
+getActiveAudioCodecList(const std::string& accountID)
{
- if (const auto acc = Manager::instance().getAccount(accountID))
+ if (auto acc = ring::Manager::instance().getAccount(accountID))
return acc->getActiveAudioCodecs();
- else {
- RING_ERR("Could not find account %s, returning default", accountID.c_str());
- return Account::getDefaultAudioCodecs();
- }
+ RING_ERR("Could not find account %s, returning default", accountID.c_str());
+ return Account::getDefaultAudioCodecs();
}
-void ConfigurationManager::setActiveAudioCodecList(const std::vector<std::string>& list, const std::string& accountID)
+void
+setActiveAudioCodecList(const std::vector<std::string>& list,
+ const std::string& accountID)
{
- if (auto acc = Manager::instance().getAccount(accountID)) {
+ if (auto acc = ring::Manager::instance().getAccount(accountID)) {
acc->setActiveAudioCodecs(list);
- Manager::instance().saveConfig();
+ ring::Manager::instance().saveConfig();
} else {
RING_ERR("Could not find account %s", accountID.c_str());
}
}
-std::vector<std::string> ConfigurationManager::getAudioPluginList()
+std::vector<std::string>
+getAudioPluginList()
{
- std::vector<std::string> v;
-
- v.push_back(PCM_DEFAULT);
- v.push_back(PCM_DMIX_DSNOOP);
-
- return v;
+ return {PCM_DEFAULT, PCM_DMIX_DSNOOP};
}
-void ConfigurationManager::setAudioPlugin(const std::string& audioPlugin)
+void
+setAudioPlugin(const std::string& audioPlugin)
{
- return Manager::instance().setAudioPlugin(audioPlugin);
+ return ring::Manager::instance().setAudioPlugin(audioPlugin);
}
-std::vector<std::string> ConfigurationManager::getAudioOutputDeviceList()
+std::vector<std::string>
+getAudioOutputDeviceList()
{
- return Manager::instance().getAudioOutputDeviceList();
+ return ring::Manager::instance().getAudioOutputDeviceList();
}
-std::vector<std::string> ConfigurationManager::getAudioInputDeviceList()
+std::vector<std::string>
+getAudioInputDeviceList()
{
- return Manager::instance().getAudioInputDeviceList();
+ return ring::Manager::instance().getAudioInputDeviceList();
}
-void ConfigurationManager::setAudioOutputDevice(int32_t index)
+void
+setAudioOutputDevice(int32_t index)
{
- return Manager::instance().setAudioDevice(index, DeviceType::PLAYBACK);
+ return ring::Manager::instance().setAudioDevice(index, DeviceType::PLAYBACK);
}
-void ConfigurationManager::setAudioInputDevice(int32_t index)
+void
+setAudioInputDevice(int32_t index)
{
- return Manager::instance().setAudioDevice(index, DeviceType::CAPTURE);
+ return ring::Manager::instance().setAudioDevice(index, DeviceType::CAPTURE);
}
-void ConfigurationManager::setAudioRingtoneDevice(int32_t index)
+void
+setAudioRingtoneDevice(int32_t index)
{
- return Manager::instance().setAudioDevice(index, DeviceType::RINGTONE);
+ return ring::Manager::instance().setAudioDevice(index, DeviceType::RINGTONE);
}
-std::vector<std::string> ConfigurationManager::getCurrentAudioDevicesIndex()
+std::vector<std::string>
+getCurrentAudioDevicesIndex()
{
- return Manager::instance().getCurrentAudioDevicesIndex();
+ return ring::Manager::instance().getCurrentAudioDevicesIndex();
}
-int32_t ConfigurationManager::getAudioInputDeviceIndex(const std::string& name)
+int32_t
+getAudioInputDeviceIndex(const std::string& name)
{
- return Manager::instance().getAudioInputDeviceIndex(name);
+ return ring::Manager::instance().getAudioInputDeviceIndex(name);
}
-int32_t ConfigurationManager::getAudioOutputDeviceIndex(const std::string& name)
+int32_t
+getAudioOutputDeviceIndex(const std::string& name)
{
- return Manager::instance().getAudioOutputDeviceIndex(name);
+ return ring::Manager::instance().getAudioOutputDeviceIndex(name);
}
-std::string ConfigurationManager::getCurrentAudioOutputPlugin()
+std::string
+getCurrentAudioOutputPlugin()
{
- RING_DBG("Get audio plugin %s", Manager::instance().getCurrentAudioOutputPlugin().c_str());
-
- return Manager::instance().getCurrentAudioOutputPlugin();
+ auto plugin = ring::Manager::instance().getCurrentAudioOutputPlugin();
+ RING_DBG("Get audio plugin %s", plugin.c_str());
+ return plugin;
}
-bool ConfigurationManager::getNoiseSuppressState()
+bool
+getNoiseSuppressState()
{
- return Manager::instance().getNoiseSuppressState();
+ return ring::Manager::instance().getNoiseSuppressState();
}
-void ConfigurationManager::setNoiseSuppressState(bool state)
+void
+setNoiseSuppressState(bool state)
{
- Manager::instance().setNoiseSuppressState(state);
+ ring::Manager::instance().setNoiseSuppressState(state);
}
-bool ConfigurationManager::isAgcEnabled()
+bool
+isAgcEnabled()
{
- return Manager::instance().isAGCEnabled();
+ return ring::Manager::instance().isAGCEnabled();
}
-void ConfigurationManager::setAgcState(bool enabled)
+void
+setAgcState(bool enabled)
{
- Manager::instance().setAGCState(enabled);
+ ring::Manager::instance().setAGCState(enabled);
}
-int32_t ConfigurationManager::isIax2Enabled()
+int32_t
+isIax2Enabled()
{
return HAVE_IAX;
}
-std::string ConfigurationManager::getRecordPath()
+std::string
+getRecordPath()
{
- return Manager::instance().audioPreference.getRecordPath();
+ return ring::Manager::instance().audioPreference.getRecordPath();
}
-void ConfigurationManager::setRecordPath(const std::string& recPath)
+void
+setRecordPath(const std::string& recPath)
{
- Manager::instance().audioPreference.setRecordPath(recPath);
+ ring::Manager::instance().audioPreference.setRecordPath(recPath);
}
-bool ConfigurationManager::getIsAlwaysRecording()
+bool
+getIsAlwaysRecording()
{
- return Manager::instance().getIsAlwaysRecording();
+ return ring::Manager::instance().getIsAlwaysRecording();
}
-void ConfigurationManager::setIsAlwaysRecording(bool rec)
+void
+setIsAlwaysRecording(bool rec)
{
- Manager::instance().setIsAlwaysRecording(rec);
+ ring::Manager::instance().setIsAlwaysRecording(rec);
}
-int32_t ConfigurationManager::getHistoryLimit()
+int32_t
+getHistoryLimit()
{
- return Manager::instance().getHistoryLimit();
+ return ring::Manager::instance().getHistoryLimit();
}
-void ConfigurationManager::clearHistory()
+void
+clearHistory()
{
- return Manager::instance().clearHistory();
+ return ring::Manager::instance().clearHistory();
}
-void ConfigurationManager::setHistoryLimit(int32_t days)
+void
+setHistoryLimit(int32_t days)
{
- Manager::instance().setHistoryLimit(days);
+ ring::Manager::instance().setHistoryLimit(days);
}
-bool ConfigurationManager::setAudioManager(const std::string& api)
+bool
+setAudioManager(const std::string& api)
{
- return Manager::instance().setAudioManager(api);
+ return ring::Manager::instance().setAudioManager(api);
}
-std::string ConfigurationManager::getAudioManager()
+std::string
+getAudioManager()
{
- return Manager::instance().getAudioManager();
+ return ring::Manager::instance().getAudioManager();
}
-void ConfigurationManager::setVolume(const std::string& device, double value)
+void
+setVolume(const std::string& device, double value)
{
- auto audiolayer = Manager::instance().getAudioDriver();
-
- if (!audiolayer) {
- RING_ERR("Audio layer not valid while updating volume");
- return;
- }
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver()) {
+ RING_DBG("set volume for %s: %f", device.c_str(), value);
- RING_DBG("set volume for %s: %f", device.c_str(), value);
+ if (device == "speaker")
+ audiolayer->setPlaybackGain(value);
+ else if (device == "mic")
+ audiolayer->setCaptureGain(value);
- if (device == "speaker") {
- audiolayer->setPlaybackGain(value);
- } else if (device == "mic") {
- audiolayer->setCaptureGain(value);
+ ring::emitSignal<ConfigurationSignal::VolumeChanged>(device, value);
+ } else {
+ RING_ERR("Audio layer not valid while updating volume");
}
-
- volumeChanged(device, value);
}
double
-ConfigurationManager::getVolume(const std::string& device)
+getVolume(const std::string& device)
{
- auto audiolayer = Manager::instance().getAudioDriver();
-
- if (!audiolayer) {
- RING_ERR("Audio layer not valid while updating volume");
- return 0.0;
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver()) {
+ if (device == "speaker")
+ return audiolayer->getPlaybackGain();
+ if (device == "mic")
+ return audiolayer->getCaptureGain();
}
- if (device == "speaker")
- return audiolayer->getPlaybackGain();
- else if (device == "mic")
- return audiolayer->getCaptureGain();
-
- return 0;
+ RING_ERR("Audio layer not valid while updating volume");
+ return 0.0;
}
// FIXME: we should store "muteDtmf" instead of "playDtmf"
// in config and avoid negating like this
-bool ConfigurationManager::isDtmfMuted()
+bool
+isDtmfMuted()
{
- return not Manager::instance().voipPreferences.getPlayDtmf();
+ return not ring::Manager::instance().voipPreferences.getPlayDtmf();
}
-void ConfigurationManager::muteDtmf(bool mute)
+void
+muteDtmf(bool mute)
{
- Manager::instance().voipPreferences.setPlayDtmf(not mute);
+ ring::Manager::instance().voipPreferences.setPlayDtmf(not mute);
}
-bool ConfigurationManager::isCaptureMuted()
+bool
+isCaptureMuted()
{
- auto audiolayer = Manager::instance().getAudioDriver();
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver())
+ return audiolayer->isCaptureMuted();
- if (!audiolayer) {
- RING_ERR("Audio layer not valid");
- return false;
- }
-
- return audiolayer->isCaptureMuted();
+ RING_ERR("Audio layer not valid");
+ return false;
}
-void ConfigurationManager::muteCapture(bool mute)
+void
+muteCapture(bool mute)
{
- auto audiolayer = Manager::instance().getAudioDriver();
-
- if (!audiolayer) {
- RING_ERR("Audio layer not valid");
- return;
- }
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver())
+ return audiolayer->muteCapture(mute);
- return audiolayer->muteCapture(mute);
+ RING_ERR("Audio layer not valid");
+ return;
}
-bool ConfigurationManager::isPlaybackMuted()
+bool
+isPlaybackMuted()
{
- auto audiolayer = Manager::instance().getAudioDriver();
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver())
+ return audiolayer->isPlaybackMuted();
- if (!audiolayer) {
- RING_ERR("Audio layer not valid");
- return false;
- }
-
- return audiolayer->isPlaybackMuted();
+ RING_ERR("Audio layer not valid");
+ return false;
}
-void ConfigurationManager::mutePlayback(bool mute)
+void
+mutePlayback(bool mute)
{
- auto audiolayer = Manager::instance().getAudioDriver();
-
- if (!audiolayer) {
- RING_ERR("Audio layer not valid");
- return;
- }
+ if (auto audiolayer = ring::Manager::instance().getAudioDriver())
+ return audiolayer->mutePlayback(mute);
- return audiolayer->mutePlayback(mute);
+ RING_ERR("Audio layer not valid");
+ return;
}
-std::map<std::string, std::string> ConfigurationManager::getHookSettings()
+std::map<std::string, std::string>
+getHookSettings()
{
- return Manager::instance().hookPreference.toMap();
+ return ring::Manager::instance().hookPreference.toMap();
}
-void ConfigurationManager::setHookSettings(const std::map<std::string,
- std::string>& settings)
+void
+setHookSettings(const std::map<std::string,
+ std::string>& settings)
{
- Manager::instance().hookPreference = HookPreference(settings);
+ ring::Manager::instance().hookPreference = HookPreference(settings);
}
-void ConfigurationManager::setAccountsOrder(const std::string& order)
+void setAccountsOrder(const std::string& order)
{
- Manager::instance().setAccountsOrder(order);
+ ring::Manager::instance().setAccountsOrder(order);
}
-std::vector<std::map<std::string, std::string> > ConfigurationManager::getHistory()
+std::vector<std::map<std::string, std::string>>
+getHistory()
{
- return Manager::instance().getHistory();
+ return ring::Manager::instance().getHistory();
}
std::string
-ConfigurationManager::getAddrFromInterfaceName(const std::string& interface)
+getAddrFromInterfaceName(const std::string& interface)
{
- return ip_utils::getInterfaceAddr(interface);
+ return ring::ip_utils::getInterfaceAddr(interface);
}
-std::vector<std::string> ConfigurationManager::getAllIpInterface()
+std::vector<std::string>
+getAllIpInterface()
{
- return ip_utils::getAllIpInterface();
+ return ring::ip_utils::getAllIpInterface();
}
-std::vector<std::string> ConfigurationManager::getAllIpInterfaceByName()
+std::vector<std::string>
+getAllIpInterfaceByName()
{
- return ip_utils::getAllIpInterfaceByName();
+ return ring::ip_utils::getAllIpInterfaceByName();
}
-std::map<std::string, std::string> ConfigurationManager::getShortcuts()
+std::map<std::string, std::string>
+getShortcuts()
{
- return Manager::instance().shortcutPreferences.getShortcuts();
+ return ring::Manager::instance().shortcutPreferences.getShortcuts();
}
-void ConfigurationManager::setShortcuts(
- const std::map<std::string, std::string>& shortcutsMap)
+void
+setShortcuts(const std::map<std::string, std::string>& shortcutsMap)
{
- Manager::instance().shortcutPreferences.setShortcuts(shortcutsMap);
- Manager::instance().saveConfig();
+ ring::Manager::instance().shortcutPreferences.setShortcuts(shortcutsMap);
+ ring::Manager::instance().saveConfig();
}
-std::vector<std::map<std::string, std::string> > ConfigurationManager::getCredentials(
- const std::string& accountID)
+std::vector<std::map<std::string, std::string>>
+getCredentials(const std::string& accountID)
{
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- std::vector<std::map<std::string, std::string> > credentialInformation;
-
- if (!sipaccount)
- return credentialInformation;
- else
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID))
return sipaccount->getCredentials();
+ return {};
}
-void ConfigurationManager::setCredentials(const std::string& accountID,
- const std::vector<std::map<std::string, std::string> >& details)
+void
+setCredentials(const std::string& accountID,
+ const std::vector<std::map<std::string, std::string>>& details)
{
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- if (sipaccount)
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID))
sipaccount->setCredentials(details);
}
-void ConfigurationManager::volumeChanged(const std::string& device, double value)
-{
- if (evHandlers_.on_volume_change) {
- evHandlers_.on_volume_change(device, value);
- }
-}
-
-void ConfigurationManager::accountsChanged()
-{
- if (evHandlers_.on_accounts_change) {
- evHandlers_.on_accounts_change();
- }
-}
-
-void ConfigurationManager::historyChanged()
-{
- if (evHandlers_.on_history_change) {
- evHandlers_.on_history_change();
- }
-}
-
-void ConfigurationManager::stunStatusFailure(const std::string& accountID)
-{
- if (evHandlers_.on_stun_status_fail) {
- evHandlers_.on_stun_status_fail(accountID);
- }
-}
-
-void ConfigurationManager::registrationStateChanged(const std::string& accountID, int state)
-{
- if (evHandlers_.on_registration_state_change) {
- evHandlers_.on_registration_state_change(accountID, state);
- }
-}
-
-void ConfigurationManager::sipRegistrationStateChanged(const std::string& accountID, const std::string& state, int32_t code)
-{
- if (evHandlers_.on_sip_registration_state_change) {
- evHandlers_.on_sip_registration_state_change(accountID, state, code);
- }
-}
-
-
-void ConfigurationManager::volatileAccountDetailsChanged(const std::string& accountID, const std::map<std::string, std::string> &details)
-{
- if (evHandlers_.on_volatile_details_change) {
- evHandlers_.on_volatile_details_change(accountID, details);
- }
-}
-
-void ConfigurationManager::errorAlert(int alert)
-{
- if (evHandlers_.on_error) {
- evHandlers_.on_error(alert);
- }
-}
-
-std::vector< int32_t > ConfigurationManager::getHardwareAudioFormat()
-{
- return std::vector<int32_t> {44100, 64};
-}
-
-} // namespace ring
+} // namespace DRing
diff --git a/daemon/src/client/configurationmanager.h b/daemon/src/client/configurationmanager.h
deleted file mode 100644
index f979c2c6aed2664aad1a9123c1a1f83c893c1b80..0000000000000000000000000000000000000000
--- a/daemon/src/client/configurationmanager.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
- * Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
- * Author: Alexandre Bourget <alexandre.bourget@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
- */
-
-#ifndef CONFIGURATIONMANAGER_H
-#define CONFIGURATIONMANAGER_H
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <vector>
-#include <map>
-#include <string>
-
-#include "dring.h"
-
-namespace ring {
-
-class ConfigurationManager
-{
- public:
- void registerEvHandlers(struct ring_config_ev_handlers* evHandlers);
-
- // Methods
- public:
- std::map< std::string, std::string > getAccountDetails(const std::string& accountID);
- std::map<std::string, std::string> getVolatileAccountDetails(const std::string& accountID);
- void setAccountDetails(const std::string& accountID, const std::map< std::string, std::string >& details);
- std::map<std::string, std::string> getAccountTemplate();
- std::string addAccount(const std::map< std::string, std::string >& details);
- void removeAccount(const std::string& accoundID);
- std::vector< std::string > getAccountList();
- void sendRegister(const std::string& accoundID, bool enable);
- void registerAllAccounts(void);
-
- std::map< std::string, std::string > getTlsSettingsDefault();
-
- std::vector< int32_t > getAudioCodecList();
- std::vector< std::string > getSupportedTlsMethod();
- std::vector< std::string > getSupportedCiphers(const std::string& accountID) const;
- std::vector< std::string > getAudioCodecDetails(int32_t payload);
- std::vector< int32_t > getActiveAudioCodecList(const std::string& accountID);
-
- void setActiveAudioCodecList(const std::vector< std::string >& list, const std::string& accountID);
-
- std::vector< std::string > getAudioPluginList();
- void setAudioPlugin(const std::string& audioPlugin);
- std::vector< std::string > getAudioOutputDeviceList();
- void setAudioOutputDevice(int32_t index);
- void setAudioInputDevice(int32_t index);
- void setAudioRingtoneDevice(int32_t index);
- std::vector< std::string > getAudioInputDeviceList();
- std::vector< std::string > getCurrentAudioDevicesIndex();
- int32_t getAudioInputDeviceIndex(const std::string& name);
- int32_t getAudioOutputDeviceIndex(const std::string& name);
- std::string getCurrentAudioOutputPlugin();
- bool getNoiseSuppressState();
- void setNoiseSuppressState(bool state);
-
- bool isAgcEnabled();
- void setAgcState(bool enabled);
-
- void muteDtmf(bool mute);
- bool isDtmfMuted();
-
- bool isCaptureMuted();
- void muteCapture(bool mute);
- bool isPlaybackMuted();
- void mutePlayback(bool mute);
-
- std::string getAudioManager();
- bool setAudioManager(const std::string& api);
-
- int32_t isIax2Enabled();
- std::string getRecordPath();
- void setRecordPath(const std::string& recPath);
- bool getIsAlwaysRecording();
- void setIsAlwaysRecording(bool rec);
-
- void setHistoryLimit(int32_t days);
- int32_t getHistoryLimit();
- void clearHistory();
-
- void setAccountsOrder(const std::string& order);
-
- std::map<std::string, std::string> getHookSettings();
- void setHookSettings(const std::map<std::string, std::string>& settings);
-
- std::vector<std::map<std::string, std::string> > getHistory();
-
- std::map<std::string, std::string> getTlsSettings();
- void setTlsSettings(const std::map< std::string, std::string >& details);
- std::map< std::string, std::string > getIp2IpDetails();
-
- std::vector< std::map< std::string, std::string > > getCredentials(const std::string& accountID);
- void setCredentials(const std::string& accountID, const std::vector< std::map< std::string, std::string > >& details);
-
- std::string getAddrFromInterfaceName(const std::string& interface);
-
- std::vector<std::string> getAllIpInterface();
- std::vector<std::string> getAllIpInterfaceByName();
-
- std::map<std::string, std::string> getShortcuts();
- void setShortcuts(const std::map<std::string, std::string> &shortcutsMap);
-
- void setVolume(const std::string& device, double value);
- double getVolume(const std::string& device);
-
- /*
- * Security
- */
- std::map<std::string, std::string> validateCertificate(const std::string& accountId,
- const std::string& certificate, const std::string& privateKey);
- std::map<std::string, std::string> getCertificateDetails(const std::string& certificate);
-
-
- // Signals
- public:
- void volumeChanged(const std::string& device, double value);
-
- void accountsChanged();
-
- void historyChanged();
-
- void stunStatusFailure(const std::string& accoundID);
-
- void registrationStateChanged(const std::string& accoundID, int state);
- void sipRegistrationStateChanged(const std::string&, const std::string&, int32_t state);
- void volatileAccountDetailsChanged(const std::string& accountID, const std::map<std::string, std::string> &details);
- void errorAlert(int alert);
-
- std::vector< int32_t > getHardwareAudioFormat();
-
- private:
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
- // Event handlers; needed by the library API
- ring_config_ev_handlers evHandlers_{};
-#pragma GCC diagnostic warning "-Wmissing-field-initializers"
-};
-
-} // namespace ring
-
-#endif //CONFIGURATIONMANAGER_H
diff --git a/daemon/src/client/presencemanager.cpp b/daemon/src/client/presencemanager.cpp
index bb7564c6278c46b5c98d75975579ae20cac3eee6..7625c1dcbca4041ba397058a75283cdd728ca1d4 100644
--- a/daemon/src/client/presencemanager.cpp
+++ b/daemon/src/client/presencemanager.cpp
@@ -1,6 +1,7 @@
/*
* Copyright (C) 2013 Savoir-Faire Linux Inc.
* Author: Patrick Keroulas <patrick.keroulas@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -32,7 +33,7 @@
#include "config.h"
#endif
-#include "presencemanager.h"
+#include "presencemanager_interface.h"
#include <cerrno>
#include <sstream>
@@ -43,39 +44,48 @@
#include "sip/sipaccount.h"
#include "sip/sippresence.h"
#include "sip/pres_sub_client.h"
+#include "client/signal.h"
-namespace ring {
+namespace DRing {
+
+using ring::SIPAccount;
constexpr static const char* STATUS_KEY = "Status";
constexpr static const char* LINESTATUS_KEY = "LineStatus";
constexpr static const char* ONLINE_KEY = "Online";
constexpr static const char* OFFLINE_KEY = "Offline";
-void PresenceManager::registerEvHandlers(struct ring_pres_ev_handlers* evHandlers)
+void
+registerPresHandlers(const std::map<std::string,
+ std::shared_ptr<CallbackWrapperBase>>& handlers)
{
- evHandlers_ = *evHandlers;
+ auto& handlers_ = ring::getSignalHandlers();
+ for (auto& item : handlers) {
+ auto iter = handlers_.find(item.first);
+ if (iter == handlers_.end()) {
+ RING_ERR("Signal %s not supported", item.first.c_str());
+ continue;
+ }
+
+ iter->second = std::move(item.second);
+ }
}
/**
* Un/subscribe to buddySipUri for an accountID
*/
void
-PresenceManager::subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag)
+subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag)
{
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- if (!sipaccount) {
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID)) {
+ auto pres = sipaccount->getPresence();
+ if (pres and pres->isEnabled() and pres->isSupported(PRESENCE_FUNCTION_SUBSCRIBE)) {
+ RING_DBG("%subscribePresence (acc:%s, buddy:%s)",
+ flag ? "S" : "Uns", accountID.c_str(), uri.c_str());
+ pres->subscribeClient(uri, flag);
+ }
+ } else
RING_ERR("Could not find account %s", accountID.c_str());
- return;
- }
-
- auto pres = sipaccount->getPresence();
-
- if (pres and pres->isEnabled() and pres->isSupported(PRESENCE_FUNCTION_SUBSCRIBE)) {
- RING_DBG("%subscribePresence (acc:%s, buddy:%s)", flag ? "S" : "Uns",
- accountID.c_str(), uri.c_str());
- pres->subscribeClient(uri, flag);
- }
}
/**
@@ -83,75 +93,58 @@ PresenceManager::subscribeBuddy(const std::string& accountID, const std::string&
* Notify for IP2IP account and publish for PBX account
*/
void
-PresenceManager::publish(const std::string& accountID, bool status, const std::string& note)
+publish(const std::string& accountID, bool status, const std::string& note)
{
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- if (!sipaccount) {
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID)) {
+ auto pres = sipaccount->getPresence();
+ if (pres and pres->isEnabled() and pres->isSupported(PRESENCE_FUNCTION_PUBLISH)) {
+ RING_DBG("Send Presence (acc:%s, status %s).", accountID.c_str(),
+ status ? "online" : "offline");
+ pres->sendPresence(status, note);
+ }
+ } else
RING_ERR("Could not find account %s.", accountID.c_str());
- return;
- }
-
- auto pres = sipaccount->getPresence();
-
- if (pres and pres->isEnabled() and pres->isSupported(PRESENCE_FUNCTION_PUBLISH)) {
- RING_DBG("Send Presence (acc:%s, status %s).", accountID.c_str(),
- status ? "online" : "offline");
- pres->sendPresence(status, note);
- }
}
/**
* Accept or not a PresSubServer request for IP2IP account
*/
void
-PresenceManager::answerServerRequest(const std::string& uri, bool flag)
+answerServerRequest(const std::string& uri, bool flag)
{
- const auto account = Manager::instance().getIP2IPAccount();
- const auto sipaccount = static_cast<SIPAccount *>(account.get());
-
- if (!sipaccount) {
+ auto account = ring::Manager::instance().getIP2IPAccount();
+ if (auto sipaccount = static_cast<SIPAccount *>(account.get())) {
+ RING_DBG("Approve presence (acc:IP2IP, serv:%s, flag:%s)", uri.c_str(),
+ flag ? "true" : "false");
+
+ if (auto pres = sipaccount->getPresence())
+ pres->approvePresSubServer(uri, flag);
+ else
+ RING_ERR("Presence not initialized");
+ } else
RING_ERR("Could not find account IP2IP");
- return;
- }
-
- RING_DBG("Approve presence (acc:IP2IP, serv:%s, flag:%s)", uri.c_str(),
- flag ? "true" : "false");
-
- auto pres = sipaccount->getPresence();
-
- if (!pres) {
- RING_ERR("Presence not initialized");
- return;
- }
-
- pres->approvePresSubServer(uri, flag);
}
/**
* Get all active subscriptions for "accountID"
*/
std::vector<std::map<std::string, std::string> >
-PresenceManager::getSubscriptions(const std::string& accountID)
+getSubscriptions(const std::string& accountID)
{
- std::vector<std::map<std::string, std::string> > ret;
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- if (sipaccount) {
- const auto pres = sipaccount->getPresence();
-
- if (!pres) {
+ std::vector<std::map<std::string, std::string>> ret;
+
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID)) {
+ if (auto pres = sipaccount->getPresence()) {
+ for (const auto& s : pres->getClientSubscriptions()) {
+ ret.push_back({
+ {STATUS_KEY, s->isPresent() ? ONLINE_KEY : OFFLINE_KEY},
+ {LINESTATUS_KEY, s->getLineStatus()}
+ });
+ }
+ } else
RING_ERR("Presence not initialized");
- return ret;
- }
-
- for (const auto& s : pres->getClientSubscriptions()) {
- std::map<std::string, std::string> sub;
- sub[ STATUS_KEY ] = s->isPresent() ? ONLINE_KEY : OFFLINE_KEY;
- sub[ LINESTATUS_KEY ] = s->getLineStatus();
- ret.push_back(sub);
- }
- }
+ } else
+ RING_ERR("Could not find account %s.", accountID.c_str());
return ret;
}
@@ -160,52 +153,16 @@ PresenceManager::getSubscriptions(const std::string& accountID)
* Batch subscribing of URIs
*/
void
-PresenceManager::setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris)
-{
- const auto sipaccount = Manager::instance().getAccount<SIPAccount>(accountID);
-
- if (!sipaccount)
- return;
-
- auto pres = sipaccount->getPresence();
-
- if (!pres) {
- RING_ERR("Presence not initialized");
- return;
- }
-
- for (const auto &u : uris)
- pres->subscribeClient(u, true);
-}
-
-void PresenceManager::newServerSubscriptionRequest(const std::string& remote)
+setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris)
{
- if (evHandlers_.on_new_server_subscription_request) {
- evHandlers_.on_new_server_subscription_request(remote);
- }
-}
-
-void PresenceManager::serverError(const std::string& accountID, const std::string& error, const std::string& msg)
-{
- if (evHandlers_.on_server_error) {
- evHandlers_.on_server_error(accountID, error, msg);
- }
-}
-
-void PresenceManager::newBuddyNotification(const std::string& accountID, const std::string& buddyUri,
- bool status, const std::string& lineStatus)
-{
- if (evHandlers_.on_new_buddy_notification) {
- evHandlers_.on_new_buddy_notification(accountID, buddyUri, status, lineStatus);
- }
-}
-
-void PresenceManager::subscriptionStateChanged(const std::string& accountID, const std::string& buddyUri,
- bool state)
-{
- if (evHandlers_.on_subscription_state_change) {
- evHandlers_.on_subscription_state_change(accountID, buddyUri, state);
- }
+ if (auto sipaccount = ring::Manager::instance().getAccount<SIPAccount>(accountID)) {
+ if (auto pres = sipaccount->getPresence()) {
+ for (const auto &u : uris)
+ pres->subscribeClient(u, true);
+ } else
+ RING_ERR("Presence not initialized");
+ } else
+ RING_ERR("Could not find account %s.", accountID.c_str());
}
-} // namespace ring
+} // namespace DRing
diff --git a/daemon/src/client/presencemanager.h b/daemon/src/client/presencemanager.h
deleted file mode 100644
index ddd24e953e1dc0d5a1a0336d1f44d4ad41aedbb8..0000000000000000000000000000000000000000
--- a/daemon/src/client/presencemanager.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2013 Savoir-Faire Linux Inc.
- * Author: Patrick Keroulas <patrick.keroulas@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
- */
-
-#ifndef PRESENCEINT_H
-#define PRESENCEINT_H
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <vector>
-#include <string>
-
-#include "dring.h"
-
-namespace ring {
-
-class PresenceManager
-{
- public:
- void registerEvHandlers(struct ring_pres_ev_handlers* evHandlers);
-
- // Methods
- public:
- /* Presence subscription/Notification. */
- void publish(const std::string& accountID, bool status, const std::string& note);
- void answerServerRequest(const std::string& uri, bool flag);
- void subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag);
- std::vector<std::map<std::string, std::string> > getSubscriptions(const std::string& accountID);
- void setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris);
-
- // Signals
- public:
- void newServerSubscriptionRequest(const std::string& remote);
- void serverError(const std::string& accountID, const std::string& error, const std::string& msg);
- void newBuddyNotification(const std::string& accountID, const std::string& buddyUri,
- bool status, const std::string& lineStatus);
- void subscriptionStateChanged(const std::string& accountID, const std::string& buddyUri, bool state);
-
- private:
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
- // Event handlers; needed by the library API
- ring_pres_ev_handlers evHandlers_{};
-#pragma GCC diagnostic warning "-Wmissing-field-initializers"
-};
-
-} // namespace ring
-
-#endif //PRESENCEINT_H
diff --git a/daemon/src/client/signal.cpp b/daemon/src/client/signal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5991976a11ae48e6e2fe76e0dbd2f3c10bb85663
--- /dev/null
+++ b/daemon/src/client/signal.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 Savoir-Faire Linux Inc.
+ * Author: Guillaume Roguez <Guillaume.Roguez@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 "signal.h"
+
+namespace ring {
+
+SignalHandlerMap&
+getSignalHandlers()
+{
+ static SignalHandlerMap handlers = {
+ /* Call */
+ exported_callback<DRing::CallSignal::StateChange>(),
+ exported_callback<DRing::CallSignal::TransferFailed>(),
+ exported_callback<DRing::CallSignal::TransferSucceeded>(),
+ exported_callback<DRing::CallSignal::RecordPlaybackStopped>(),
+ exported_callback<DRing::CallSignal::VoiceMailNotify>(),
+ exported_callback<DRing::CallSignal::IncomingMessage>(),
+ exported_callback<DRing::CallSignal::IncomingCall>(),
+ exported_callback<DRing::CallSignal::RecordPlaybackFilepath>(),
+ exported_callback<DRing::CallSignal::ConferenceCreated>(),
+ exported_callback<DRing::CallSignal::ConferenceChanged>(),
+ exported_callback<DRing::CallSignal::UpdatePlaybackScale>(),
+ exported_callback<DRing::CallSignal::ConferenceRemoved>(),
+ exported_callback<DRing::CallSignal::NewCallCreated>(),
+ exported_callback<DRing::CallSignal::SipCallStateChanged>(),
+ exported_callback<DRing::CallSignal::RecordingStateChanged>(),
+ exported_callback<DRing::CallSignal::SecureSdesOn>(),
+ exported_callback<DRing::CallSignal::SecureSdesOff>(),
+ exported_callback<DRing::CallSignal::SecureZrtpOn>(),
+ exported_callback<DRing::CallSignal::SecureZrtpOff>(),
+ exported_callback<DRing::CallSignal::ShowSAS>(),
+ exported_callback<DRing::CallSignal::ZrtpNotSuppOther>(),
+ exported_callback<DRing::CallSignal::ZrtpNegotiationFailed>(),
+ exported_callback<DRing::CallSignal::RtcpReportReceived>(),
+
+ /* Configuration */
+ exported_callback<DRing::ConfigurationSignal::VolumeChanged>(),
+ exported_callback<DRing::ConfigurationSignal::AccountsChanged>(),
+ exported_callback<DRing::ConfigurationSignal::HistoryChanged>(),
+ exported_callback<DRing::ConfigurationSignal::StunStatusFailed>(),
+ exported_callback<DRing::ConfigurationSignal::RegistrationStateChanged>(),
+ exported_callback<DRing::ConfigurationSignal::SipRegistrationStateChanged>(),
+ exported_callback<DRing::ConfigurationSignal::VolatileDetailsChanged>(),
+ exported_callback<DRing::ConfigurationSignal::Error>(),
+
+ /* Presence */
+ exported_callback<DRing::PresenceSignal::NewServerSubscriptionRequest>(),
+ exported_callback<DRing::PresenceSignal::ServerError>(),
+ exported_callback<DRing::PresenceSignal::NewBuddyNotification>(),
+ exported_callback<DRing::PresenceSignal::SubscriptionStateChanged>(),
+
+ /* Video */
+ exported_callback<DRing::VideoSignal::DeviceEvent>(),
+ exported_callback<DRing::VideoSignal::DecodingStarted>(),
+ exported_callback<DRing::VideoSignal::DecodingStopped>(),
+ };
+
+ return handlers;
+}
+
+}; // namespace ring
diff --git a/daemon/src/client/signal.h b/daemon/src/client/signal.h
new file mode 100644
index 0000000000000000000000000000000000000000..28a66a90576a05d0d3b68ffa68f7fa55d4bc02de
--- /dev/null
+++ b/daemon/src/client/signal.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2015 Savoir-Faire Linux Inc.
+ * Author: Guillaume Roguez <Guillaume.Roguez@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
+ */
+
+#pragma once
+
+#include "dring/callmanager_interface.h"
+#include "dring/configurationmanager_interface.h"
+#include "dring/presencemanager_interface.h"
+
+#ifdef RING_VIDEO
+#include "dring/videomanager_interface.h"
+#endif // RING_VIDEO
+
+#include "logger.h"
+
+#include <exception>
+#include <memory>
+
+namespace ring {
+
+using SignalHandlerMap = std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>>;
+extern SignalHandlerMap& getSignalHandlers();
+
+/*
+ * Find related user given callback and call it with given
+ * arguments.
+ */
+template <typename Ts, typename ...Args>
+static void emitSignal(Args...args) {
+ const auto& handlers = getSignalHandlers();
+ if (auto cb = *DRing::CallbackWrapper<typename Ts::cb_type> {handlers.at(Ts::name)}) {
+ try {
+ cb(args...);
+ } catch (std::exception& e) {
+ RING_ERR("Exception during emit signal %d:\n%s", Ts::name, e.what());
+ }
+ }
+}
+
+template <typename Ts>
+std::pair<std::string, std::shared_ptr<DRing::CallbackWrapper<typename Ts::cb_type>>>
+exported_callback() {
+ return std::make_pair((const std::string&)Ts::name, std::make_shared<DRing::CallbackWrapper<typename Ts::cb_type>>());
+}
+
+} // namespace ring
diff --git a/daemon/src/client/videomanager.cpp b/daemon/src/client/videomanager.cpp
index 2afdd9f6e8a8e809b4af96bc5362cac125d515e9..5ec3995271f51243bf96b652203d0e27679bbbd1 100644
--- a/daemon/src/client/videomanager.cpp
+++ b/daemon/src/client/videomanager.cpp
@@ -30,6 +30,7 @@
* as that of the covered work.
*/
+#include "videomanager_interface.h"
#include "videomanager.h"
#include "libav_utils.h"
#include "video/video_input.h"
@@ -37,151 +38,150 @@
#include "account.h"
#include "logger.h"
#include "manager.h"
+#include "client/signal.h"
-namespace ring {
+namespace DRing {
-void VideoManager::registerEvHandlers(struct ring_video_ev_handlers* evHandlers)
-{
- evHandlers_ = *evHandlers;
-}
+using ring::videoManager;
-video::VideoDeviceMonitor &
-VideoManager::getVideoDeviceMonitor()
-{
- return videoDeviceMonitor_;
+void
+registerVideoHandlers(const std::map<std::string,
+ std::shared_ptr<CallbackWrapperBase>>& handlers)
+{
+ auto& handlers_ = ring::getSignalHandlers();
+ for (auto& item : handlers) {
+ auto iter = handlers_.find(item.first);
+ if (iter == handlers_.end()) {
+ RING_ERR("Signal %s not supported", item.first.c_str());
+ continue;
+ }
+
+ iter->second = std::move(item.second);
+ }
}
-std::vector<std::map<std::string, std::string> >
-VideoManager::getCodecs(const std::string &accountID)
+
+std::vector<std::map<std::string, std::string>>
+getCodecs(const std::string& accountID)
{
- if (const auto acc = Manager::instance().getAccount(accountID))
+ if (auto acc = ring::Manager::instance().getAccount(accountID))
return acc->getAllVideoCodecs();
- else
- return std::vector<std::map<std::string, std::string> >();
+ return {};
}
void
-VideoManager::setCodecs(const std::string& accountID,
- const std::vector<std::map<std::string, std::string> > &details)
+setCodecs(const std::string& accountID,
+ const std::vector<std::map<std::string, std::string>>& details)
{
- if (auto acc = Manager::instance().getAccount(accountID)) {
+ if (auto acc = ring::Manager::instance().getAccount(accountID)) {
acc->setVideoCodecs(details);
- Manager::instance().saveConfig();
+ ring::Manager::instance().saveConfig();
}
}
std::vector<std::string>
-VideoManager::getDeviceList()
+getDeviceList()
{
- return videoDeviceMonitor_.getDeviceList();
+ return videoManager.videoDeviceMonitor.getDeviceList();
}
-video::VideoCapabilities
-VideoManager::getCapabilities(const std::string& name)
+VideoCapabilities
+getCapabilities(const std::string& name)
{
- return videoDeviceMonitor_.getCapabilities(name);
+ return videoManager.videoDeviceMonitor.getCapabilities(name);
}
std::string
-VideoManager::getDefaultDevice()
+getDefaultDevice()
{
- return videoDeviceMonitor_.getDefaultDevice();
+ return videoManager.videoDeviceMonitor.getDefaultDevice();
}
void
-VideoManager::setDefaultDevice(const std::string &name)
+setDefaultDevice(const std::string& name)
{
RING_DBG("Setting device to %s", name.c_str());
- videoDeviceMonitor_.setDefaultDevice(name);
+ videoManager.videoDeviceMonitor.setDefaultDevice(name);
}
std::map<std::string, std::string>
-VideoManager::getSettings(const std::string& name) {
- return videoDeviceMonitor_.getSettings(name);
+getSettings(const std::string& name)
+{
+ return videoManager.videoDeviceMonitor.getSettings(name);
}
void
-VideoManager::applySettings(const std::string& name,
- const std::map<std::string, std::string>& settings)
+applySettings(const std::string& name,
+ const std::map<std::string, std::string>& settings)
{
- videoDeviceMonitor_.applySettings(name, settings);
+ videoManager.videoDeviceMonitor.applySettings(name, settings);
}
void
-VideoManager::startCamera()
+startCamera()
{
- videoPreview_ = getVideoCamera();
- started_ = switchToCamera();
+ videoManager.videoPreview = ring::getVideoCamera();
+ videoManager.started = switchToCamera();
}
void
-VideoManager::stopCamera()
+stopCamera()
{
if (switchInput(""))
- started_ = false;
- videoPreview_.reset();
+ videoManager.started = false;
+ videoManager.videoPreview.reset();
}
bool
-VideoManager::switchInput(const std::string &resource)
+switchInput(const std::string& resource)
{
- auto input = videoInput_.lock();
- if (!input) {
- RING_WARN("Video input not initialized");
- return false;
- }
- return input->switchInput(resource);
+ if (auto input = videoManager.videoInput.lock())
+ return input->switchInput(resource);
+
+ RING_WARN("Video input not initialized");
+ return false;
}
bool
-VideoManager::switchToCamera()
+switchToCamera()
{
- return switchInput("v4l2://" + videoDeviceMonitor_.getDefaultDevice());
-}
-
-std::shared_ptr<video::VideoFrameActiveWriter>
-VideoManager::getVideoCamera()
-{
- auto input = videoInput_.lock();
- if (!input) {
- started_ = false;
- input.reset(new video::VideoInput());
- videoInput_ = input;
- }
- return input;
+ return switchInput("v4l2://" + videoManager.videoDeviceMonitor.getDefaultDevice());
}
bool
-VideoManager::hasCameraStarted()
+hasCameraStarted()
{
- return started_;
+ return videoManager.started;
}
std::string
-VideoManager::getCurrentCodecName(const std::string & /*callID*/)
+getCurrentCodecName(const std::string& /*callID*/)
{
return "";
}
-void VideoManager::deviceEvent()
-{
- if (evHandlers_.on_device_event) {
- evHandlers_.on_device_event();
- }
-}
+} // namespace DRing
+
+namespace ring {
-void VideoManager::startedDecoding(const std::string &id, const std::string& shmPath, int w, int h, bool isMixer)
+VideoManager videoManager;
+
+std::shared_ptr<video::VideoFrameActiveWriter>
+getVideoCamera()
{
- if (evHandlers_.on_start_decoding) {
- evHandlers_.on_start_decoding(id, shmPath, w, h, isMixer);
- }
+ if (auto input = videoManager.videoInput.lock())
+ return input;
+
+ videoManager.started = false;
+ auto input = std::make_shared<video::VideoInput>();
+ videoManager.videoInput = input;
+ return input;
}
-void VideoManager::stoppedDecoding(const std::string &id, const std::string& shmPath, bool isMixer)
+video::VideoDeviceMonitor&
+getVideoDeviceMonitor()
{
- if (evHandlers_.on_stop_decoding) {
- evHandlers_.on_stop_decoding(id, shmPath, isMixer);
- }
+ return videoManager.videoDeviceMonitor;
}
} // namespace ring
diff --git a/daemon/src/client/videomanager.h b/daemon/src/client/videomanager.h
index d287ca320d3708a07927182f472ffdcad5ec2d0e..c7772faa6232f6bfcd3fe18a300228102c3efd8c 100644
--- a/daemon/src/client/videomanager.h
+++ b/daemon/src/client/videomanager.h
@@ -43,13 +43,12 @@
#include "video/video_base.h"
#include "video/video_input.h"
-#include "dring.h"
namespace ring {
-class VideoManager
+struct VideoManager
{
- private:
+ public:
/* VideoManager acts as a cache of the active VideoInput.
* When this input is needed, you must use getVideoCamera
* to create the instance if not done yet and obtain a shared pointer
@@ -58,63 +57,16 @@ class VideoManager
* this video input instance: this instance is destroyed when the last
* external user has released its shared pointer.
*/
- std::weak_ptr<video::VideoInput> videoInput_ = {};
- std::shared_ptr<video::VideoFrameActiveWriter> videoPreview_ = nullptr;
- video::VideoDeviceMonitor videoDeviceMonitor_ = {};
-
- public:
- void registerEvHandlers(struct ring_video_ev_handlers* evHandlers);
- video::VideoDeviceMonitor& getVideoDeviceMonitor();
-
- // Methods
- public:
- std::vector<std::map<std::string, std::string> >
- getCodecs(const std::string& accountID);
-
- void
- setCodecs(const std::string& accountID,
- const std::vector<std::map<std::string, std::string> > &details);
-
- std::vector<std::string>
- getDeviceList();
-
- video::VideoCapabilities
- getCapabilities(const std::string& name);
-
- std::map<std::string, std::string>
- getSettings(const std::string& name);
-
- void
- applySettings(const std::string& name, const std::map<std::string, std::string>& settings);
-
- void
- setDefaultDevice(const std::string& name);
-
- std::string
- getDefaultDevice();
-
- std::string
- getCurrentCodecName(const std::string &callID);
-
- std::atomic_bool started_ = {false};
- void startCamera();
- void stopCamera();
- bool hasCameraStarted();
- bool switchInput(const std::string& resource);
- bool switchToCamera();
- std::shared_ptr<video::VideoFrameActiveWriter> getVideoCamera();
+ std::weak_ptr<video::VideoInput> videoInput;
+ std::shared_ptr<video::VideoFrameActiveWriter> videoPreview;
+ video::VideoDeviceMonitor videoDeviceMonitor;
+ std::atomic_bool started;
+};
- // Signals
- public:
- void deviceEvent();
- void startedDecoding(const std::string &id, const std::string& shmPath, int w, int h, bool isMixer);
- void stoppedDecoding(const std::string &id, const std::string& shmPath, bool isMixer);
+extern VideoManager videoManager;
- private:
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
- ring_video_ev_handlers evHandlers_{};
-#pragma GCC diagnostic warning "-Wmissing-field-initializers"
-};
+std::shared_ptr<video::VideoFrameActiveWriter> getVideoCamera();
+video::VideoDeviceMonitor& getVideoDeviceMonitor();
} // namespace ring
diff --git a/daemon/src/dring/callmanager_interface.h b/daemon/src/dring/callmanager_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..f53970542ccce5840562cb74730ebc9efba32682
--- /dev/null
+++ b/daemon/src/dring/callmanager_interface.h
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
+ * Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
+ */
+
+#ifndef __RING_CALLMANAGERI_H__
+#define __RING_CALLMANAGERI_H__
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdexcept>
+#include <map>
+#include <vector>
+#include <string>
+#include <functional>
+#include <string>
+
+#include "dring.h"
+
+namespace DRing {
+
+class CallManagerException: public std::runtime_error {
+ public:
+ CallManagerException(const std::string& str = "") :
+ std::runtime_error("A CallManagerException occured: " + str) {}
+};
+
+// Call signal type definitions
+struct CallSignal {
+ struct StateChange {
+ constexpr static const char* name = "StateChange";
+ using cb_type = void(const std::string&, const std::string&);
+ };
+ struct TransferFailed {
+ constexpr static const char* name = "TransferFailed";
+ using cb_type = void(void);
+ };
+ struct TransferSucceeded {
+ constexpr static const char* name = "TransferSucceeded";
+ using cb_type = void(void);
+ };
+ struct RecordPlaybackStopped {
+ constexpr static const char* name = "RecordPlaybackStopped";
+ using cb_type = void(const std::string&);
+ };
+ struct VoiceMailNotify {
+ constexpr static const char* name = "VoiceMailNotify";
+ using cb_type = void(const std::string&, int32_t);
+ };
+ struct IncomingMessage {
+ constexpr static const char* name = "IncomingMessage";
+ using cb_type = void(const std::string&, const std::string&, const std::string&);
+ };
+ struct IncomingCall {
+ constexpr static const char* name = "IncomingCall";
+ using cb_type = void(const std::string&, const std::string&, const std::string&);
+ };
+ struct RecordPlaybackFilepath {
+ constexpr static const char* name = "RecordPlaybackFilepath";
+ using cb_type = void(const std::string&, const std::string&);
+ };
+ struct ConferenceCreated {
+ constexpr static const char* name = "ConferenceCreated";
+ using cb_type = void(const std::string&);
+ };
+ struct ConferenceChanged {
+ constexpr static const char* name = "ConferenceChanged";
+ using cb_type = void(const std::string&, const std::string&);
+ };
+ struct UpdatePlaybackScale {
+ constexpr static const char* name = "UpdatePlaybackScale";
+ using cb_type = void(const std::string&, unsigned, unsigned);
+ };
+ struct ConferenceRemoved {
+ constexpr static const char* name = "ConferenceRemoved";
+ using cb_type = void(const std::string&);
+ };
+ struct NewCallCreated {
+ constexpr static const char* name = "NewCallCreated";
+ using cb_type = void(const std::string&, const std::string&, const std::string&);
+ };
+ struct SipCallStateChanged {
+ constexpr static const char* name = "SipCallStateChanged";
+ using cb_type = void(const std::string&, const std::string&, int);
+ };
+ struct RecordingStateChanged {
+ constexpr static const char* name = "RecordingStateChanged";
+ using cb_type = void(const std::string&, int);
+ };
+ struct SecureSdesOn {
+ constexpr static const char* name = "SecureSdesOn";
+ using cb_type = void(const std::string&);
+ };
+ struct SecureSdesOff {
+ constexpr static const char* name = "SecureSdesOff";
+ using cb_type = void(const std::string&);
+ };
+ struct SecureZrtpOn {
+ constexpr static const char* name = "SecureZrtpOn";
+ using cb_type = void(const std::string&, const std::string&);
+ };
+ struct SecureZrtpOff {
+ constexpr static const char* name = "SecureZrtpOff";
+ using cb_type = void(const std::string&);
+ };
+ struct ShowSAS {
+ constexpr static const char* name = "ShowSAS";
+ using cb_type = void(const std::string&, const std::string&, int);
+ };
+ struct ZrtpNotSuppOther {
+ constexpr static const char* name = "ZrtpNotSuppOther";
+ using cb_type = void(const std::string&);
+ };
+ struct ZrtpNegotiationFailed {
+ constexpr static const char* name = "ZrtpNegotiationFailed";
+ using cb_type = void(const std::string&, const std::string&, const std::string&);
+ };
+ struct RtcpReportReceived {
+ constexpr static const char* name = "RtcpReportReceived";
+ using cb_type = void(const std::string&, const std::map<std::string, int>&);
+ };
+};
+
+void registerCallHandlers(const std::map<std::string, std::shared_ptr<CallbackWrapperBase>>&);
+
+/* Call related methods */
+bool placeCall(const std::string& accountID, const std::string& callID, const std::string& to);
+
+bool refuse(const std::string& callID);
+bool accept(const std::string& callID);
+bool hangUp(const std::string& callID);
+bool hold(const std::string& callID);
+bool unhold(const std::string& callID);
+bool transfer(const std::string& callID, const std::string& to);
+bool attendedTransfer(const std::string& transferID, const std::string& targetID);
+std::map<std::string, std::string> getCallDetails(const std::string& callID);
+std::vector<std::string> getCallList();
+
+/* Conference related methods */
+void removeConference(const std::string& conference_id);
+bool joinParticipant(const std::string& sel_callID, const std::string& drag_callID);
+void createConfFromParticipantList(const std::vector<std::string>& participants);
+bool isConferenceParticipant(const std::string& call_id);
+bool addParticipant(const std::string& callID, const std::string& confID);
+bool addMainParticipant(const std::string& confID);
+bool detachParticipant(const std::string& callID);
+bool joinConference(const std::string& sel_confID, const std::string& drag_confID);
+bool hangUpConference(const std::string& confID);
+bool holdConference(const std::string& confID);
+bool unholdConference(const std::string& confID);
+std::vector<std::string> getConferenceList();
+std::vector<std::string> getParticipantList(const std::string& confID);
+std::vector<std::string> getDisplayNames(const std::string& confID);
+std::string getConferenceId(const std::string& callID);
+std::map<std::string, std::string> getConferenceDetails(const std::string& callID);
+
+/* File Playback methods */
+bool startRecordedFilePlayback(const std::string& filepath);
+void stopRecordedFilePlayback(const std::string& filepath);
+
+/* General audio methods */
+bool toggleRecording(const std::string& callID);
+/* DEPRECATED */
+void setRecording(const std::string& callID);
+
+void recordPlaybackSeek(double value);
+bool getIsRecording(const std::string& callID);
+std::string getCurrentAudioCodecName(const std::string& callID);
+void playDTMF(const std::string& key);
+void startTone(int32_t start, int32_t type);
+
+/* Security related methods */
+void setSASVerified(const std::string& callID);
+void resetSASVerified(const std::string& callID);
+void setConfirmGoClear(const std::string& callID);
+void requestGoClear(const std::string& callID);
+void acceptEnrollment(const std::string& callID, bool accepted);
+
+/* Instant messaging */
+void sendTextMessage(const std::string& callID, const std::string& message);
+void sendTextMessage(const std::string& callID, const std::string& message, const std::string& from);
+
+} // namespace DRing
+
+#endif//CALLMANAGERI_H
diff --git a/daemon/src/dring/configurationmanager_interface.h b/daemon/src/dring/configurationmanager_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5847313f81c91ba72af0de9638749f43a4f8453
--- /dev/null
+++ b/daemon/src/dring/configurationmanager_interface.h
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2004-2015 Savoir-Faire Linux Inc.
+ * Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
+ * Author: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
+ * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
+ * Author: Guillaume Carmel-Archambault <guillaume.carmel-archambault@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
+ */
+
+#ifndef CONFIGURATIONMANAGERI_H
+#define CONFIGURATIONMANAGERI_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <vector>
+#include <map>
+#include <string>
+#include <functional>
+#include <tuple>
+
+#include "dring.h"
+
+namespace DRing {
+
+// Configuration signal type definitions
+struct ConfigurationSignal {
+ struct VolumeChanged {
+ constexpr static const char* name = "VolumeChanged";
+ using cb_type = void(const std::string& /*device*/, double /*value*/);
+ };
+ struct AccountsChanged {
+ constexpr static const char* name = "AccountsChanged";
+ using cb_type = void(void);
+ };
+ struct HistoryChanged {
+ constexpr static const char* name = "HistoryChanged";
+ using cb_type = void(void);
+ };
+ struct StunStatusFailed {
+ constexpr static const char* name = "StunStatusFailed";
+ using cb_type = void(const std::string& /*account_id*/);
+ };
+ struct RegistrationStateChanged {
+ constexpr static const char* name = "RegistrationStateChanged";
+ using cb_type = void(const std::string& /*account_id*/, int /*state*/);
+ };
+ struct SipRegistrationStateChanged {
+ constexpr static const char* name = "SipRegistrationStateChanged";
+ using cb_type = void(const std::string& /*account_id*/, const std::string& /*state*/, int /*code*/);
+ };
+ struct VolatileDetailsChanged {
+ constexpr static const char* name = "VolatileDetailsChanged";
+ using cb_type = void(const std::string& /*account_id*/, const std::map<std::string, std::string>& /* details */);
+ };
+ struct Error {
+ constexpr static const char* name = "Error";
+ using cb_type = void(int /*alert*/);
+ };
+};
+
+
+void registerConfHandlers(const std::map<std::string, std::shared_ptr<CallbackWrapperBase>>&);
+
+std::map<std::string, std::string> getAccountDetails(const std::string& accountID);
+std::map<std::string, std::string> getVolatileAccountDetails(const std::string& accountID);
+void setAccountDetails(const std::string& accountID, const std::map<std::string, std::string>& details);
+std::map<std::string, std::string> getAccountTemplate();
+std::string addAccount(const std::map<std::string, std::string>& details);
+void removeAccount(const std::string& accoundID);
+std::vector<std::string> getAccountList();
+void sendRegister(const std::string& accoundID, bool enable);
+void registerAllAccounts(void);
+
+std::map<std::string, std::string> getTlsDefaultSettings();
+
+std::vector<int32_t> getAudioCodecList();
+std::vector<std::string> getSupportedTlsMethod();
+std::vector<std::string> getSupportedCiphers(const std::string& accountID);
+std::vector<std::string> getAudioCodecDetails(int32_t payload);
+std::vector<int32_t> getActiveAudioCodecList(const std::string& accountID);
+
+void setActiveAudioCodecList(const std::vector<std::string>& list, const std::string& accountID);
+
+std::vector<std::string> getAudioPluginList();
+void setAudioPlugin(const std::string& audioPlugin);
+std::vector<std::string> getAudioOutputDeviceList();
+void setAudioOutputDevice(int32_t index);
+void setAudioInputDevice(int32_t index);
+void setAudioRingtoneDevice(int32_t index);
+std::vector<std::string> getAudioInputDeviceList();
+std::vector<std::string> getCurrentAudioDevicesIndex();
+int32_t getAudioInputDeviceIndex(const std::string& name);
+int32_t getAudioOutputDeviceIndex(const std::string& name);
+std::string getCurrentAudioOutputPlugin();
+bool getNoiseSuppressState();
+void setNoiseSuppressState(bool state);
+
+bool isAgcEnabled();
+void setAgcState(bool enabled);
+
+void muteDtmf(bool mute);
+bool isDtmfMuted();
+
+bool isCaptureMuted();
+void muteCapture(bool mute);
+bool isPlaybackMuted();
+void mutePlayback(bool mute);
+
+std::string getAudioManager();
+bool setAudioManager(const std::string& api);
+
+int32_t isIax2Enabled();
+std::string getRecordPath();
+void setRecordPath(const std::string& recPath);
+bool getIsAlwaysRecording();
+void setIsAlwaysRecording(bool rec);
+
+void setHistoryLimit(int32_t days);
+int32_t getHistoryLimit();
+void clearHistory();
+
+void setAccountsOrder(const std::string& order);
+
+std::map<std::string, std::string> getHookSettings();
+void setHookSettings(const std::map<std::string, std::string>& settings);
+
+std::vector<std::map<std::string, std::string>> getHistory();
+
+std::map<std::string, std::string> getTlsSettings();
+void setTlsSettings(const std::map<std::string, std::string>& details);
+std::map<std::string, std::string> getIp2IpDetails();
+
+std::vector<std::map<std::string, std::string>> getCredentials(const std::string& accountID);
+void setCredentials(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details);
+
+std::string getAddrFromInterfaceName(const std::string& interface);
+
+std::vector<std::string> getAllIpInterface();
+std::vector<std::string> getAllIpInterfaceByName();
+
+std::map<std::string, std::string> getShortcuts();
+void setShortcuts(const std::map<std::string, std::string> &shortcutsMap);
+
+void setVolume(const std::string& device, double value);
+double getVolume(const std::string& device);
+
+/*
+ * Security
+ */
+std::map<std::string, std::string> validateCertificate(const std::string& accountId,
+ const std::string& certificate, const std::string& privateKey);
+std::map<std::string, std::string> getCertificateDetails(const std::string& certificate);
+
+} // namespace DRing
+
+#endif //CONFIGURATIONMANAGERI_H
diff --git a/daemon/src/dring/dring.h b/daemon/src/dring/dring.h
index dd5081df3d70201ea906f7ba6941222caa1d1ad8..818fa0183425265d2834705d678db00d80628695 100644
--- a/daemon/src/dring/dring.h
+++ b/daemon/src/dring/dring.h
@@ -1,6 +1,7 @@
/*
- * Copyright (C) 2014 Savoir-Faire Linux Inc.
+ * Copyright (C) 2014-2015 Savoir-Faire Linux Inc.
* Author: Philippe Proulx <philippe.proulx@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -27,8 +28,8 @@
* shall include the source code for the parts of OpenSSL used as well
* as that of the covered work.
*/
-#ifndef RING_H
-#define RING_H
+#ifndef DRING_H
+#define DRING_H
#ifdef HAVE_CONFIG_H
#include "config.h"
@@ -38,97 +39,104 @@
#include <functional>
#include <string>
#include <map>
+#include <memory>
+#include <type_traits>
-const char *
-ring_version();
+namespace DRing {
-/* presence events */
-struct ring_pres_ev_handlers
-{
- std::function<void (const std::string& /*remote*/)> on_new_server_subscription_request;
- std::function<void (const std::string& /*account_id*/, const std::string& /*error*/, const std::string& /*msg*/)> on_server_error;
- std::function<void (const std::string& /*account_id*/, const std::string& /*buddy_uri*/, int /*status*/, const std::string& /*line_status*/)> on_new_buddy_notification;
- std::function<void (const std::string& /*account_id*/, const std::string& /*buddy_uri*/, int /*state*/)> on_subscription_state_change;
-};
-
-/* configuration events */
-struct ring_config_ev_handlers
-{
- std::function<void (const std::string& /*device*/, double /*value*/)> on_volume_change;
- std::function<void ()> on_accounts_change;
- std::function<void ()> on_history_change;
- std::function<void (const std::string& /*account_id*/)> on_stun_status_fail;
- std::function<void (const std::string& /*account_id*/, int /*state*/)> on_registration_state_change;
- std::function<void (const std::string& /*account_id*/, const std::string& /*state*/, int /*code*/)> on_sip_registration_state_change;
- std::function<void (const std::string& /*account_id*/, const std::map<std::string, std::string>& /* details */)> on_volatile_details_change;
- std::function<void (int /*alert*/)> on_error;
-};
+enum class EventHandlerKey { CALL, CONFIG, PRESENCE, VIDEO };
-/* call events */
-struct ring_call_ev_handlers
-{
- std::function<void (const std::string& /*call_id*/, const std::string& /*state*/)> on_state_change;
- std::function<void ()> on_transfer_fail;
- std::function<void ()> on_transfer_success;
- std::function<void (const std::string& /*path*/)> on_record_playback_stopped;
- std::function<void (const std::string& /*call_id*/, int /*nd_msg*/)> on_voice_mail_notify;
- std::function<void (const std::string& /*id*/, const std::string& /*from*/, const std::string& /*msg*/)> on_incoming_message;
- std::function<void (const std::string& /*account_id*/, const std::string& /*call_id*/, const std::string& /*from*/)> on_incoming_call;
- std::function<void (const std::string& /*id*/, const std::string& /*filename*/)> on_record_playback_filepath;
- std::function<void (const std::string& /*conf_id*/)> on_conference_created;
- std::function<void (const std::string& /*conf_id*/, const std::string& /*state*/)> on_conference_changed;
- std::function<void (const std::string& /*filepath*/, int /*position*/, int /*scale*/)> on_update_playback_scale;
- std::function<void (const std::string& /*conf_id*/)> on_conference_remove;
- std::function<void (const std::string& /*account_id*/, const std::string& /*call_id*/, const std::string& /*to*/)> on_new_call;
- std::function<void (const std::string& /*call_id*/, const std::string& /*state*/, int /*code*/)> on_sip_call_state_change;
- std::function<void (const std::string& /*call_id*/, int /*state*/)> on_record_state_change;
- std::function<void (const std::string& /*call_id*/)> on_secure_sdes_on;
- std::function<void (const std::string& /*call_id*/)> on_secure_sdes_off;
- std::function<void (const std::string& /*call_id*/, const std::string& /*cipher*/)> on_secure_zrtp_on;
- std::function<void (const std::string& /*call_id*/)> on_secure_zrtp_off;
- std::function<void (const std::string& /*call_id*/, const std::string& /*sas*/, int /*verified*/)> on_show_sas;
- std::function<void (const std::string& /*call_id*/)> on_zrtp_not_supp_other;
- std::function<void (const std::string& /*call_id*/, const std::string& /*reason*/, const std::string& /*severity*/)> on_zrtp_negotiation_fail;
- std::function<void (const std::string& /*call_id*/, const std::map<std::string, int>& /*stats*/)> on_rtcp_receive_report;
+/* error codes returned by functions of this API */
+enum class InitResult {
+ SUCCESS=0,
+ ERR_MANAGER_INIT,
};
-/* video events */
-#ifdef RING_VIDEO
-struct ring_video_ev_handlers
-{
- std::function<void ()> on_device_event;
- std::function<void (const std::string& /*id*/, const std::string& /*shm_path*/, int /*w*/, int /*h*/, bool /*is_mixer*/)> on_start_decoding;
- std::function<void (const std::string& /*id*/, const std::string& /*shm_path*/, bool /*is_mixer*/)> on_stop_decoding;
+/* flags for initialization */
+enum InitFlag {
+ DRING_FLAG_DEBUG=1,
+ DRING_FLAG_CONSOLE_LOG=2,
};
-#endif /* RING_VIDEO */
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+/* External Callback Dynamic Utilities
+ *
+ * The library provides to users a way to be acknowledged
+ * when daemon's objects have a state change.
+ * The user is aware of this changement wen the deamon calls
+ * a user-given callback.
+ * Daemon handles many of these callbacks, one per event type.
+ * The user registers his callback when he calls daemon DRing:init().
+ * Each callback has its own function signature.
+ * To keep ABI compatibility we don't let user directly provides
+ * his callbacks as it or through a structure.
+ * This way bring ABI violation if we need to change the order
+ * and/or the existance of any callback type.
+ * Thus the user have to pass them using following template classes
+ * and functions, that wraps user-callback in a generic and ABI-compatible way.
+ */
-/* all handlers */
-struct ring_ev_handlers
-{
- ring_call_ev_handlers call_ev_handlers;
- ring_config_ev_handlers config_ev_handlers;
- ring_pres_ev_handlers pres_ev_handlers;
+/* Generic class to transit user callbacks to daemon library.
+ * Used conjointly with std::shared_ptr to hide the concrete class.
+ * See CallbackWrapper template for details.
+ */
+class CallbackWrapperBase {};
-#ifdef RING_VIDEO
- ring_video_ev_handlers video_ev_handlers;
-#endif /* RING_VIDEO */
+/* Concrete class of CallbackWrapperBase.
+ * This class wraps callbacks of a specific signature.
+ * Also used to obtain the user callback from a CallbackWrapperBase shared ptr.
+ *
+ * This class is CopyConstructible, CopyAssignable, MoveConstructible
+ * and MoveAssignable.
+ */
+template <typename TProto>
+class CallbackWrapper : public CallbackWrapperBase {
+ private:
+ using TFunc = std::function<TProto>;
+ TFunc cb_; // The user-callback
+
+ public:
+ // Empty wrapper: no callback associated.
+ // Used to initialize internal callback arrays.
+ CallbackWrapper() noexcept {}
+
+ // Create and initialize a wrapper to given callback.
+ CallbackWrapper(TFunc&& func) noexcept {
+ cb_ = std::forward<TFunc>(func);
+ }
+
+ // Create and initialize a wrapper from a generic CallbackWrapperBase
+ // shared pointer.
+ // Note: the given callback is copied into internal storage.
+ CallbackWrapper(std::shared_ptr<CallbackWrapperBase> p) noexcept {
+ if (p)
+ cb_ = ((CallbackWrapper<TProto>*)p.get())->cb_;
+ }
+
+ // Return user-callback reference.
+ // The returned std::function can be null-initialized if no callback
+ // has been set.
+ const constexpr TFunc& operator *() const noexcept {
+ return cb_;
+ }
+
+ // Return boolean true value if a non-null callback has been set
+ explicit constexpr operator bool() const noexcept {
+ return static_cast<bool>(cb_);
+ }
};
-#pragma GCC diagnostic warning "-Wmissing-field-initializers"
+// Return an exportable callback object.
+// This object is a std::pair of a string and a CallbackWrapperBase shared_ptr.
+// This last wraps given callback in a ABI-compatible way.
+// Note: this version accepts callback as a rvalue.
+template <typename Ts>
+std::pair<std::string, std::shared_ptr<CallbackWrapperBase>>
+exportable_callback(std::function<typename Ts::cb_type>&& func) {
+ return std::make_pair((const std::string&)Ts::name, std::make_shared<CallbackWrapper<typename Ts::cb_type>>(std::forward<std::function<typename Ts::cb_type>>(func)));
+}
-/* error codes returned by functions of this API */
-enum ring_error {
- RING_ERR_MANAGER_INIT,
- RING_ERR_UNKNOWN,
-};
-
-/* flags for initialization */
-enum ring_init_flag {
- RING_FLAG_DEBUG = 1,
- RING_FLAG_CONSOLE_LOG = 2,
-};
+/* Return the library version */
+const char* version() noexcept;
/**
* Initializes libring.
@@ -137,152 +145,21 @@ enum ring_init_flag {
* @param flags Flags to customize this initialization
* @returns 0 if successful or a negative error code
*/
-int ring_init(struct ring_ev_handlers* ev_handlers, enum ring_init_flag flags);
+InitResult
+init(const std::map<EventHandlerKey,
+ std::map<std::string, std::shared_ptr<CallbackWrapperBase>>>& ev_handlers,
+ enum InitFlag flags);
/**
* Finalizes libring, freeing any resource allocated by the library.
*/
-void ring_fini(void);
+void fini(void) noexcept;
/**
- * Poll for SIP/IAX events
+ * Poll for Daemon events
*/
-void ring_poll_events(void);
-
-/* call API */
-bool ring_call_place(const std::string& account_id, const std::string& call_id, const std::string& to);
-bool ring_call_refuse(const std::string& call_id);
-bool ring_call_accept(const std::string& call_id);
-bool ring_call_hang_up(const std::string& call_id);
-bool ring_call_hold(const std::string& call_id);
-bool ring_call_unhold(const std::string& call_id);
-bool ring_call_transfer(const std::string& call_id, const std::string& to);
-bool ring_call_attended_transfer(const std::string& transfer_id, const std::string& target_id);
-std::map<std::string, std::string> ring_call_get_call_details(const std::string& call_id);
-std::vector<std::string> ring_call_get_call_list(void);
-void ring_call_remove_conference(const std::string& conf_id);
-bool ring_call_join_participant(const std::string& sel_call_id, const std::string& drag_call_id);
-void ring_call_create_conf_from_participant_list(const std::vector<std::string>& participants);
-bool ring_call_is_conference_participant(const std::string& call_id);
-bool ring_call_add_participant(const std::string& call_id, const std::string& conf_id);
-bool ring_call_add_main_participant(const std::string& conf_id);
-bool ring_call_detach_participant(const std::string& call_id);
-bool ring_call_join_conference(const std::string& sel_conf_id, const std::string& drag_conf_id);
-bool ring_call_hang_up_conference(const std::string& conf_id);
-bool ring_call_hold_conference(const std::string& conf_id);
-bool ring_call_unhold_conference(const std::string& conf_id);
-std::vector<std::string> ring_call_get_conference_list(void);
-std::vector<std::string> ring_call_get_participant_list(const std::string& conf_id);
-std::vector<std::string> ring_call_get_display_names(const std::string& conf_id);
-std::string ring_call_get_conference_id(const std::string& call_id);
-std::map<std::string, std::string> ring_call_get_conference_details(const std::string& call_id);
-bool ring_call_play_recorded_file(const std::string& path);
-void ring_call_stop_recorded_file(const std::string& path);
-bool ring_call_toggle_recording(const std::string& call_id);
-void ring_call_set_recording(const std::string& call_id);
-void ring_call_record_playback_seek(double pos);
-bool ring_call_is_recording(const std::string& call_id);
-std::string ring_call_get_current_audio_codec_name(const std::string& call_id);
-void ring_call_play_dtmf(const std::string& key);
-void ring_call_start_tone(int start, int type);
-void ring_call_set_sas_verified(const std::string& call_id);
-void ring_call_reset_sas_verified(const std::string& call_id);
-void ring_call_set_confirm_go_clear(const std::string& call_id);
-void ring_call_request_go_clear(const std::string& call_id);
-void ring_call_accept_enrollment(const std::string& call_id, bool accepted);
-void ring_call_send_text_message(const std::string& call_id, const std::string& message);
-
-/* configuration API */
-std::map<std::string, std::string> ring_config_get_account_details(const std::string& account_id);
-std::map<std::string, std::string> ring_config_get_volatile_account_details(const std::string& account_id);
-void ring_config_set_account_details(const std::string& account_id, const std::map<std::string, std::string>& details);
-std::map<std::string, std::string> ring_config_get_account_template(void);
-std::string ring_config_add_account(const std::map<std::string, std::string>& details);
-void ring_config_remove_account(const std::string& account_id);
-std::vector<std::string> ring_config_get_account_list(void);
-void ring_config_send_register(const std::string& account_id, bool enable);
-void ring_config_register_all_accounts(void);
-std::map<std::string, std::string> ring_config_get_tls_default_settings(void);
-std::vector<int> ring_config_get_audio_codec_list(void);
-std::vector<std::string> ring_config_get_supported_tls_method(void);
-std::vector<std::string> ring_config_get_supported_ciphers(const std::string& account_id);
-std::vector<std::string> ring_config_get_audio_codec_details(int payload);
-std::vector<int> ring_config_get_active_audio_codec_list(const std::string& account_id);
-void ring_config_set_active_audio_codec_list(const std::vector<std::string>& list, const std::string& account_id);
-std::vector<std::string> ring_config_get_audio_plugin_list(void);
-void ring_config_set_audio_plugin(const std::string& audio_plugin);
-std::vector<std::string> ring_config_get_audio_output_device_list();
-void ring_config_set_audio_output_device(int index);
-void ring_config_set_audio_input_device(int index);
-void ring_config_set_audio_ringtone_device(int index);
-std::vector<std::string> ring_config_get_audio_input_device_list(void);
-std::vector<std::string> ring_config_get_current_audio_devices_index(void);
-int ring_config_get_audio_input_device_index(const std::string& name);
-int ring_config_get_audio_output_device_index(const std::string& name);
-std::string ring_config_get_current_audio_output_plugin(void);
-bool ring_config_get_noise_suppress_state(void);
-void ring_config_set_noise_suppress_state(bool state);
-bool ring_config_is_agc_enabled(void);
-void ring_config_enable_agc(bool enabled);
-void ring_config_mute_dtmf(bool mute);
-bool ring_config_is_dtmf_muted(void);
-bool ring_config_is_capture_muted(void);
-void ring_config_mute_capture(bool mute);
-bool ring_config_is_playback_muted(void);
-void ring_config_mute_playback(int mute);
-std::string ring_config_get_audio_manager(void);
-bool ring_config_set_audio_manager(const std::string& api);
-std::vector<std::string> ring_config_get_supported_audio_managers(void);
-int ring_config_is_iax2_enabled(void);
-std::string ring_config_get_record_path(void);
-void ring_config_set_record_path(const std::string& path);
-bool ring_config_is_always_recording(void);
-void ring_config_set_always_recording(bool rec);
-void ring_config_set_history_limit(int days);
-int ring_config_get_history_limit(void);
-void ring_config_clear_history(void);
-void ring_config_set_accounts_order(const std::string& order);
-std::map<std::string, std::string> ring_config_get_hook_settings(void);
-void ring_config_set_hook_settings(const std::map<std::string, std::string>& settings);
-std::vector<std::map<std::string, std::string>> ring_config_get_history(void);
-std::map<std::string, std::string> ring_config_get_tls_settings();
-std::map<std::string, std::string> ring_config_validate_certificate(const std::string& accountId,
- const std::string& certificate, const std::string& private_key);
-std::map<std::string, std::string> ring_config_get_certificate_details(const std::string& certificate);
-void ring_config_set_tls_settings(const std::map< std::string, std::string >& settings);
-std::map<std::string, std::string> ring_config_get_ip2ip_details(void);
-std::vector<std::map<std::string, std::string>> ring_config_get_credentials(const std::string& account_id);
-void ring_config_set_credentials(const std::string& account_id, const std::vector<std::map<std::string, std::string>>& details);
-std::string ring_config_get_addr_from_interface_name(const std::string& interface);
-std::vector<std::string> ring_config_get_all_ip_interface(void);
-std::vector<std::string> ring_config_get_all_ip_interface_by_name(void);
-std::map<std::string, std::string> ring_config_get_shortcuts();
-void ring_config_set_shortcuts(const std::map<std::string, std::string>& shortcuts);
-void ring_config_set_volume(const std::string& device, double value);
-double ring_config_get_volume(const std::string& device);
-
-/* presence API */
-void ring_pres_publish(const std::string& account_id, int status, const std::string& note);
-void ring_pres_answer_server_request(const std::string& uri, int flag);
-void ring_pres_subscribe_buddy(const std::string& account_id, const std::string& uri, int flag);
-std::vector<std::map<std::string, std::string>> ring_pres_get_subscriptions(const std::string& account_id);
-void ring_pres_set_subscriptions(const std::string& account_id, const std::vector<std::string>& uris);
+void poll_events(void);
-/* video API */
-#ifdef RING_VIDEO
-std::vector<std::map<std::string, std::string>> ring_video_get_codecs(const std::string& account_id);
-void ring_video_set_codecs(const std::string& account_id, const std::vector<std::map<std::string, std::string>>& details);
-std::vector<std::string> ring_video_get_device_list(void);
-std::map<std::string, std::map<std::string, std::vector<std::string>>> ring_video_get_capabilities(const std::string& name);
-std::map<std::string, std::string> ring_video_get_settings(const std::string& name);
-void ring_video_set_default_device(const std::string& dev);
-std::string ring_video_get_default_device(void);
-std::string ring_video_get_current_codec_name(const std::string& call_id);
-void ring_video_start_camera(void);
-void ring_video_stop_camera(void);
-bool ring_video_switch_input(const std::string& resource);
-bool ring_video_is_camera_started(void);
-void ring_video_apply_settings(const std::string& name, const std::map<std::string, std::string>& settings);
-#endif /* RING_VIDEO */
+} // namespace DRing
-#endif /* RING_H */
+#endif /* DRING_H */
diff --git a/daemon/src/dring/presencemanager_interface.h b/daemon/src/dring/presencemanager_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..36c5b47e2c3d1bae1e8bc12d6c6ac6b0e0e1ffb0
--- /dev/null
+++ b/daemon/src/dring/presencemanager_interface.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2013 Savoir-Faire Linux Inc.
+ * Author: Patrick Keroulas <patrick.keroulas@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
+ */
+
+#ifndef PRESENCEMANAGERI_H
+#define PRESENCEMANAGERI_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <vector>
+#include <map>
+#include <string>
+#include <functional>
+
+#include "dring.h"
+
+namespace DRing {
+
+// Presence signal type definitions
+struct PresenceSignal {
+ struct NewServerSubscriptionRequest {
+ constexpr static const char* name = "NewServerSubscriptionRequest";
+ using cb_type = void(const std::string& /*remote*/);
+ };
+ struct ServerError {
+ constexpr static const char* name = "ServerError";
+ using cb_type = void(const std::string& /*account_id*/, const std::string& /*error*/, const std::string& /*msg*/);
+ };
+ struct NewBuddyNotification {
+ constexpr static const char* name = "NewBuddyNotification";
+ using cb_type = void(const std::string& /*account_id*/, const std::string& /*buddy_uri*/, int /*status*/, const std::string& /*line_status*/);
+ };
+ struct SubscriptionStateChanged {
+ constexpr static const char* name = "SubscriptionStateChanged";
+ using cb_type = void(const std::string& /*account_id*/, const std::string& /*buddy_uri*/, int /*state*/);
+ };
+};
+
+void registerPresHandlers(const std::map<std::string, std::shared_ptr<CallbackWrapperBase>>&);
+
+/* Presence subscription/Notification. */
+void publish(const std::string& accountID, bool status, const std::string& note);
+void answerServerRequest(const std::string& uri, bool flag);
+void subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag);
+std::vector<std::map<std::string, std::string>> getSubscriptions(const std::string& accountID);
+void setSubscriptions(const std::string& accountID, const std::vector<std::string>& uris);
+
+} // namespace DRing
+
+#endif //PRESENCEMANAGERI_H
diff --git a/daemon/src/dring/videomanager_interface.h b/daemon/src/dring/videomanager_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f683e9f5817fe4021ebae1cdd02f784be5a0b5b
--- /dev/null
+++ b/daemon/src/dring/videomanager_interface.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2012-2014 Savoir-Faire Linux Inc.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
+ */
+
+#ifndef VIDEOMANAGERI_H_
+#define VIDEOMANAGERI_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <memory> // for weak/shared_ptr
+#include <vector>
+#include <atomic>
+#include <map>
+#include <string>
+
+#include "dring.h"
+
+namespace DRing {
+
+using VideoCapabilities = std::map<std::string, std::map<std::string, std::vector<std::string>>>;
+
+// Video signal type definitions
+struct VideoSignal {
+ struct DeviceEvent {
+ constexpr static const char* name = "DeviceEvent";
+ using cb_type = void(void);
+ };
+ struct DecodingStarted {
+ constexpr static const char* name = "DecodingStarted";
+ using cb_type = void(const std::string& /*id*/, const std::string& /*shm_path*/, int /*w*/, int /*h*/, bool /*is_mixer*/id);
+ };
+ struct DecodingStopped {
+ constexpr static const char* name = "DecodingStopped";
+ using cb_type = void(const std::string& /*id*/, const std::string& /*shm_path*/, bool /*is_mixer*/);
+ };
+};
+
+void registerVideoHandlers(const std::map<std::string, std::shared_ptr<CallbackWrapperBase>>&);
+
+std::vector<std::map<std::string, std::string>> getCodecs(const std::string& accountID);
+void setCodecs(const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details);
+std::vector<std::string> getDeviceList();
+VideoCapabilities getCapabilities(const std::string& name);
+std::map<std::string, std::string> getSettings(const std::string& name);
+void applySettings(const std::string& name, const std::map<std::string, std::string>& settings);
+void setDefaultDevice(const std::string& name);
+std::string getDefaultDevice();
+std::string getCurrentCodecName(const std::string& callID);
+void startCamera();
+void stopCamera();
+bool hasCameraStarted();
+bool switchInput(const std::string& resource);
+bool switchToCamera();
+
+} // namespace DRing
+
+#endif // VIDEOMANAGERI_H_
diff --git a/daemon/src/managerimpl.cpp b/daemon/src/managerimpl.cpp
index ac55958ab8520157970fa70726cabf1ff2b5ef83..cb709ce9ace601d50029c47ebba5ef146c1bc4f2 100644
--- a/daemon/src/managerimpl.cpp
+++ b/daemon/src/managerimpl.cpp
@@ -6,7 +6,7 @@
* Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
* Author: Alexandre Savard <alexandre.savard@savoirfairelinux.com>
* Author: Guillaume Carmel-Archambault <guillaume.carmel-archambault@savoirfairelinux.com>
- * Author : Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
+ * Author: Guillaume Roguez <guillaume.roguez@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
@@ -71,10 +71,6 @@
#include "history/history.h"
#include "manager.h"
-#include "client/configurationmanager.h"
-#include "client/callmanager.h"
-#include "client/presencemanager.h"
-
#ifdef RING_VIDEO
#include "client/videomanager.h"
#endif
@@ -82,6 +78,8 @@
#include "conference.h"
#include "ice_transport.h"
+#include "client/signal.h"
+
#include <cerrno>
#include <algorithm>
#include <ctime>
@@ -160,12 +158,7 @@ ManagerImpl::ManagerImpl() :
, preferences(), voipPreferences(),
hookPreference(), audioPreference(), shortcutPreferences(),
hasTriedToRegister_(false), audioCodecFactory(*pluginManager_),
- callManager_(new CallManager), configurationManager_(new ConfigurationManager),
- presenceManager_(new PresenceManager)
-#ifdef RING_VIDEO
- , videoManager_(new VideoManager)
-#endif
- , currentCallMutex_(), dtmfKey_(), dtmfBuf_(0, AudioFormat::MONO()),
+ currentCallMutex_(), dtmfKey_(), dtmfBuf_(0, AudioFormat::MONO()),
toneMutex_(), telephoneTone_(), audiofile_(), audioLayerMutex_(),
waitingCalls_(), waitingCallsMutex_(), path_()
, ringbufferpool_(new RingBufferPool)
@@ -182,32 +175,6 @@ ManagerImpl::ManagerImpl() :
ManagerImpl::~ManagerImpl()
{}
-CallManager*
-ManagerImpl::getCallManager()
-{
- return callManager_.get();
-}
-
-ConfigurationManager*
-ManagerImpl::getConfigurationManager()
-{
- return configurationManager_.get();
-}
-
-PresenceManager*
-ManagerImpl::getPresenceManager()
-{
- return presenceManager_.get();
-}
-
-#ifdef RING_VIDEO
-VideoManager*
-ManagerImpl::getVideoManager()
-{
- return videoManager_.get();
-}
-#endif
-
bool
ManagerImpl::parseConfiguration()
{
@@ -314,7 +281,7 @@ ManagerImpl::setPath(const std::string &path)
}
void
-ManagerImpl::finish()
+ManagerImpl::finish() noexcept
{
bool expected = false;
if (not finished_.compare_exchange_strong(expected, true))
@@ -525,7 +492,8 @@ ManagerImpl::answerCall(const std::string& call_id)
if (audioPreference.getIsAlwaysRecording())
toggleRecordingCall(call_id);
- getCallManager()->callStateChanged(call_id, "CURRENT");
+ //callStateChanged(call_id, "CURRENT");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "CURRENT");
return result;
}
@@ -550,7 +518,7 @@ ManagerImpl::hangupCall(const std::string& callId)
stopTone();
RING_DBG("Send call state change (HUNGUP) for id %s", callId.c_str());
- getCallManager()->callStateChanged(callId, "HUNGUP");
+ emitSignal<DRing::CallSignal::StateChange>(callId, "HUNGUP");
/* We often get here when the call was hungup before being created */
auto call = getCallFromCallID(callId);
@@ -641,7 +609,7 @@ ManagerImpl::onHoldCall(const std::string& callId)
if (current_call_id == callId)
unsetCurrentCall();
- getCallManager()->callStateChanged(callId, "HOLD");
+ emitSignal<DRing::CallSignal::StateChange>(callId, "HOLD");
return result;
}
@@ -679,7 +647,7 @@ ManagerImpl::offHoldCall(const std::string& callId)
return false;
}
- getCallManager()->callStateChanged(callId, "UNHOLD");
+ emitSignal<DRing::CallSignal::StateChange>(callId, "UNHOLD");
if (isConferenceParticipant(callId))
switchCall(getCallFromCallID(call->getConfId()));
@@ -714,13 +682,13 @@ ManagerImpl::transferCall(const std::string& callId, const std::string& to)
void
ManagerImpl::transferFailed()
{
- getCallManager()->transferFailed();
+ emitSignal<DRing::CallSignal::TransferFailed>();
}
void
ManagerImpl::transferSucceeded()
{
- getCallManager()->transferSucceeded();
+ transferSucceeded();
}
bool
@@ -754,7 +722,7 @@ ManagerImpl::refuseCall(const std::string& id)
removeWaitingCall(id);
- getCallManager()->callStateChanged(id, "HUNGUP");
+ emitSignal<DRing::CallSignal::StateChange>(id, "HUNGUP");
// Disconnect streams
removeStream(*call);
@@ -775,7 +743,7 @@ ManagerImpl::createConference(const std::string& id1, const std::string& id2)
// Add conference to map
conferenceMap_.insert(std::make_pair(conf->getConfID(), conf));
- getCallManager()->conferenceCreated(conf->getConfID());
+ emitSignal<DRing::CallSignal::ConferenceCreated>(conf->getConfID());
return conf;
}
@@ -797,7 +765,7 @@ ManagerImpl::removeConference(const std::string& conference_id)
return;
}
- getCallManager()->conferenceRemoved(conference_id);
+ emitSignal<DRing::CallSignal::ConferenceRemoved>(conference_id);
// We now need to bind the audio to the remain participant
@@ -857,7 +825,7 @@ ManagerImpl::holdConference(const std::string& id)
conf->setState(isRec ? Conference::HOLD_REC : Conference::HOLD);
- getCallManager()->conferenceChanged(conf->getConfID(), conf->getStateStr());
+ emitSignal<DRing::CallSignal::ConferenceChanged>(conf->getConfID(), conf->getStateStr());
return true;
}
@@ -890,7 +858,7 @@ ManagerImpl::unHoldConference(const std::string& id)
conf->setState(isRec ? Conference::ACTIVE_ATTACHED_REC : Conference::ACTIVE_ATTACHED);
- getCallManager()->conferenceChanged(conf->getConfID(), conf->getStateStr());
+ emitSignal<DRing::CallSignal::ConferenceChanged>(conf->getConfID(), conf->getStateStr());
return true;
}
@@ -1020,7 +988,7 @@ ManagerImpl::addMainParticipant(const std::string& conference_id)
else
RING_WARN("Invalid conference state while adding main participant");
- getCallManager()->conferenceChanged(conference_id, conf->getStateStr());
+ emitSignal<DRing::CallSignal::ConferenceChanged>(conference_id, conf->getStateStr());
}
switchCall(getCallFromCallID(conference_id));
@@ -1164,7 +1132,7 @@ ManagerImpl::createConfFromParticipantList(const std::vector< std::string > &par
if (!callSuccess)
conf->remove(generatedCallID);
else {
- getCallManager()->newCallCreated(account, generatedCallID, tostr);
+ emitSignal<DRing::CallSignal::NewCallCreated>(account, generatedCallID, tostr);
successCounter++;
}
}
@@ -1172,7 +1140,7 @@ ManagerImpl::createConfFromParticipantList(const std::vector< std::string > &par
// Create the conference if and only if at least 2 calls have been successfully created
if (successCounter >= 2) {
conferenceMap_[conf->getConfID()] = conf;
- getCallManager()->conferenceCreated(conf->getConfID());
+ emitSignal<DRing::CallSignal::ConferenceCreated>(conf->getConfID());
conf->setRecordingFormat(ringbufferpool_->getInternalAudioFormat());
}
}
@@ -1234,8 +1202,7 @@ ManagerImpl::detachParticipant(const std::string& call_id)
else
RING_WARN("Undefined behavior, invalid conference state in detach participant");
- getCallManager()->conferenceChanged(conf->getConfID(),
- conf->getStateStr());
+ emitSignal<DRing::CallSignal::ConferenceChanged>(conf->getConfID(), conf->getStateStr());
unsetCurrentCall();
}
@@ -1268,7 +1235,7 @@ ManagerImpl::removeParticipant(const std::string& call_id)
removeStream(*call);
- getCallManager()->conferenceChanged(conf->getConfID(), conf->getStateStr());
+ emitSignal<DRing::CallSignal::ConferenceChanged>(conf->getConfID(), conf->getStateStr());
processRemainingParticipants(*conf);
}
@@ -1444,7 +1411,7 @@ ManagerImpl::saveConfig()
hookPreference.serialize(out);
audioPreference.serialize(out);
#ifdef RING_VIDEO
- getVideoManager()->getVideoDeviceMonitor().serialize(out);
+ getVideoDeviceMonitor().serialize(out);
#endif
shortcutPreferences.serialize(out);
@@ -1574,7 +1541,7 @@ ManagerImpl::incomingCall(Call &call, const std::string& accountId)
std::string from("<" + number + ">");
- getCallManager()->incomingCall(accountId, callID, call.getDisplayName() + " " + from);
+ emitSignal<DRing::CallSignal::IncomingCall>(accountId, callID, call.getDisplayName() + " " + from);
}
//THREAD=VoIP
@@ -1605,10 +1572,10 @@ ManagerImpl::incomingMessage(const std::string& callID,
}
// in case of a conference we must notify client using conference id
- getCallManager()->incomingMessage(conf->getConfID(), from, message);
+ incomingMessage(conf->getConfID(), from, message);
} else
- getCallManager()->incomingMessage(callID, from, message);
+ incomingMessage(callID, from, message);
}
//THREAD=VoIP
@@ -1697,7 +1664,7 @@ ManagerImpl::peerAnsweredCall(Call& call)
if (audioPreference.getIsAlwaysRecording())
toggleRecordingCall(call_id);
- getCallManager()->callStateChanged(call_id, "CURRENT");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "CURRENT");
}
//THREAD=VoIP Call=Outgoing
@@ -1710,7 +1677,7 @@ ManagerImpl::peerRingingCall(Call& call)
if (isCurrentCall(call))
ringback();
- getCallManager()->callStateChanged(call_id, "RINGING");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "RINGING");
}
//THREAD=VoIP Call=Outgoing/Ingoing
@@ -1731,7 +1698,7 @@ ManagerImpl::peerHungupCall(Call& call)
call.peerHungup();
saveHistory();
- getCallManager()->callStateChanged(call_id, "HUNGUP");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "HUNGUP");
checkAudio();
removeWaitingCall(call_id);
@@ -1747,7 +1714,7 @@ ManagerImpl::callBusy(Call& call)
{
const auto call_id = call.getCallId();
- getCallManager()->callStateChanged(call_id, "BUSY");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "BUSY");
if (isCurrentCall(call)) {
playATone(Tone::TONE_BUSY);
@@ -1764,7 +1731,7 @@ ManagerImpl::callFailure(Call& call)
{
const auto call_id = call.getCallId();
- getCallManager()->callStateChanged(call_id, "FAILURE");
+ emitSignal<DRing::CallSignal::StateChange>(call_id, "FAILURE");
if (isCurrentCall(call)) {
playATone(Tone::TONE_BUSY);
@@ -1786,7 +1753,7 @@ void
ManagerImpl::startVoiceMessageNotification(const std::string& accountId,
int nb_msg)
{
- getCallManager()->voiceMailNotify(accountId, nb_msg);
+ emitSignal<DRing::CallSignal::VoiceMailNotify>(accountId, nb_msg);
}
/**
@@ -1833,7 +1800,7 @@ ManagerImpl::stopTone()
if (audiofile_) {
std::string filepath(audiofile_->getFilePath());
- getCallManager()->recordPlaybackStopped(filepath);
+ emitSignal<DRing::CallSignal::RecordPlaybackStopped>(filepath);
audiofile_.reset();
}
}
@@ -1926,7 +1893,7 @@ ManagerImpl::playRingtone(const std::string& accountID)
std::lock_guard<std::mutex> m(toneMutex_);
if (audiofile_) {
- getCallManager()->recordPlaybackStopped(audiofile_->getFilePath());
+ emitSignal<DRing::CallSignal::RecordPlaybackStopped>(audiofile_->getFilePath());
audiofile_.reset();
}
@@ -2145,8 +2112,8 @@ ManagerImpl::toggleRecordingCall(const std::string& id)
}
const bool result = rec->toggleRecording();
- getCallManager()->recordPlaybackFilepath(id, rec->getFilename());
- getCallManager()->recordingStateChanged(id, result);
+ emitSignal<DRing::CallSignal::RecordPlaybackFilepath>(id, rec->getFilename());
+ emitSignal<DRing::CallSignal::RecordingStateChanged>(id, result);
return result;
}
@@ -2178,7 +2145,7 @@ ManagerImpl::startRecordedFilePlayback(const std::string& filepath)
std::lock_guard<std::mutex> m(toneMutex_);
if (audiofile_) {
- getCallManager()->recordPlaybackStopped(audiofile_->getFilePath());
+ emitSignal<DRing::CallSignal::RecordPlaybackStopped>(audiofile_->getFilePath());
audiofile_.reset();
}
@@ -2217,7 +2184,7 @@ void ManagerImpl::stopRecordedFilePlayback(const std::string& filepath)
std::lock_guard<std::mutex> m(toneMutex_);
audiofile_.reset();
}
- getCallManager()->recordPlaybackStopped(filepath);
+ emitSignal<DRing::CallSignal::RecordPlaybackStopped>(filepath);
}
void ManagerImpl::setHistoryLimit(int days)
@@ -2477,7 +2444,7 @@ ManagerImpl::setAccountDetails(const std::string& accountID,
account->doUnregister();
// Update account details to the client side
- getConfigurationManager()->accountsChanged();
+ emitSignal<DRing::ConfigurationSignal::AccountsChanged>();
});
}
@@ -2522,7 +2489,7 @@ ManagerImpl::addAccount(const std::map<std::string, std::string>& details)
saveConfig();
- getConfigurationManager()->accountsChanged();
+ emitSignal<DRing::ConfigurationSignal::AccountsChanged>();
return newAccountID;
}
@@ -2545,7 +2512,7 @@ void ManagerImpl::removeAccount(const std::string& accountID)
saveConfig();
- getConfigurationManager()->accountsChanged();
+ emitSignal<DRing::ConfigurationSignal::AccountsChanged>();
}
bool
@@ -2630,8 +2597,7 @@ ManagerImpl::loadAccountMap(const YAML::Node &node)
int errorCount = 0;
try {
#ifdef RING_VIDEO
- VideoManager *controls(getVideoManager());
- controls->getVideoDeviceMonitor().unserialize(node);
+ getVideoDeviceMonitor().unserialize(node);
#endif
} catch (const YAML::Exception &e) {
RING_ERR("%s: No video node in config file", e.what());
@@ -2743,7 +2709,7 @@ ManagerImpl::saveHistory()
if (!history_.save())
RING_ERR("Could not save history!");
else
- getConfigurationManager()->historyChanged();
+ emitSignal<DRing::ConfigurationSignal::AccountsChanged>();
}
void
diff --git a/daemon/src/managerimpl.h b/daemon/src/managerimpl.h
index 41e3daaa11e2853596ea9e560ccec3eca9b1d4da..ec943c945b292ba1881865d50251731018d18942 100644
--- a/daemon/src/managerimpl.h
+++ b/daemon/src/managerimpl.h
@@ -73,12 +73,6 @@ class PluginManager;
class AudioFile;
class DTMF;
class TelephoneTone;
-class ConfigurationManager;
-class PresenceManager;
-class CallManager;
-#ifdef RING_VIDEO
-class VideoManager;
-#endif
/** To send multiple string */
typedef std::list<std::string> TokenList;
@@ -101,13 +95,6 @@ class ManagerImpl {
ManagerImpl();
~ManagerImpl();
- std::unique_ptr<ConfigurationManager> configurationManager_;
- std::unique_ptr<CallManager> callManager_;
- std::unique_ptr<PresenceManager> presenceManager_;
-
-#ifdef RING_VIDEO
- std::unique_ptr<VideoManager> videoManager_;
-#endif
/**
* General preferences configuration
*/
@@ -148,7 +135,7 @@ class ManagerImpl {
/*
* Terminate all threads and exit DBus loop
*/
- void finish();
+ void finish() noexcept;
/**
* Accessor to audiodriver.
@@ -881,14 +868,6 @@ class ManagerImpl {
*/
bool hasCurrentCall() const;
- CallManager* getCallManager();
- ConfigurationManager* getConfigurationManager();
- PresenceManager* getPresenceManager();
-
-#ifdef RING_VIDEO
- VideoManager * getVideoManager();
-#endif
-
std::vector<std::map<std::string, std::string> > getHistory();
void clearHistory();
diff --git a/daemon/src/media/audio/alsa/alsalayer.cpp b/daemon/src/media/audio/alsa/alsalayer.cpp
index 698883a97cac7e958d41bca7eed853206b813304..05e3733972735747a162c7b4d2deb26700894923 100644
--- a/daemon/src/media/audio/alsa/alsalayer.cpp
+++ b/daemon/src/media/audio/alsa/alsalayer.cpp
@@ -34,7 +34,7 @@
#include "logger.h"
#include "manager.h"
#include "noncopyable.h"
-#include "client/configurationmanager.h"
+#include "client/signal.h"
#include "audio/ringbufferpool.h"
#include "audio/ringbuffer.h"
#include "audio/resampler.h"
@@ -103,18 +103,18 @@ void AlsaThread::initAudioLayer(void)
alsa_->is_capture_open_ = alsa_->openDevice(&alsa_->captureHandle_, pcmc, SND_PCM_STREAM_CAPTURE);
if (not alsa_->is_capture_open_)
- Manager::instance().getConfigurationManager()->errorAlert(ALSA_CAPTURE_DEVICE);
+ emitSignal<DRing::ConfigurationSignal::Error>(ALSA_CAPTURE_DEVICE);
}
if (not alsa_->is_playback_open_) {
alsa_->is_playback_open_ = alsa_->openDevice(&alsa_->playbackHandle_, pcmp, SND_PCM_STREAM_PLAYBACK);
if (not alsa_->is_playback_open_)
- Manager::instance().getConfigurationManager()->errorAlert(ALSA_PLAYBACK_DEVICE);
+ emitSignal<DRing::ConfigurationSignal::Error>(ALSA_PLAYBACK_DEVICE);
if (alsa_->getIndexPlayback() != alsa_->getIndexRingtone())
if (!alsa_->openDevice(&alsa_->ringtoneHandle_, pcmr, SND_PCM_STREAM_PLAYBACK))
- Manager::instance().getConfigurationManager()->errorAlert(ALSA_PLAYBACK_DEVICE);
+ emitSignal<DRing::ConfigurationSignal::Error>(ALSA_PLAYBACK_DEVICE);
}
alsa_->hardwareFormatAvailable(alsa_->getFormat());
diff --git a/daemon/src/media/audio/sound/audiofile.cpp b/daemon/src/media/audio/sound/audiofile.cpp
index 010d74b5b164e79b0c8692a2ee075359b4adf9f7..f4622b46285f6e60a8569d45765bf8cb8a472939 100644
--- a/daemon/src/media/audio/sound/audiofile.cpp
+++ b/daemon/src/media/audio/sound/audiofile.cpp
@@ -40,8 +40,8 @@
#include "audiofile.h"
#include "audio/resampler.h"
-#include "client/callmanager.h"
#include "manager.h"
+#include "client/signal.h"
#include "logger.h"
@@ -58,10 +58,10 @@ AudioFile::onBufferFinish()
return;
}
- if ((updatePlaybackScale_ % 5) == 0) {
- CallManager *cm = Manager::instance().getCallManager();
- cm->updatePlaybackScale(filepath_, pos_ / divisor, buffer_->frames() / divisor);
- }
+ if ((updatePlaybackScale_ % 5) == 0)
+ emitSignal<DRing::CallSignal::UpdatePlaybackScale>(filepath_,
+ (unsigned)(pos_ / divisor),
+ (unsigned)(buffer_->frames() / divisor));
updatePlaybackScale_++;
}
diff --git a/daemon/src/media/video/v4l2/video_device_impl.cpp b/daemon/src/media/video/v4l2/video_device_impl.cpp
index 9b804e50c1a5bdfc8bac75af32b2970d51fdf6c2..4b6cb6e00e11830de6cfb0e9411ef57c60f2d817 100644
--- a/daemon/src/media/video/v4l2/video_device_impl.cpp
+++ b/daemon/src/media/video/v4l2/video_device_impl.cpp
@@ -567,10 +567,10 @@ VideoDevice::getSettings() const
return deviceImpl_->getSettings();
}
-VideoCapabilities
+DRing::VideoCapabilities
VideoDevice::getCapabilities() const
{
- VideoCapabilities cap;
+ DRing::VideoCapabilities cap;
for (const auto& chan : deviceImpl_->getChannelList())
for (const auto& size : deviceImpl_->getSizeList(chan))
diff --git a/daemon/src/media/video/video_device.h b/daemon/src/media/video/video_device.h
index 47ec3bc40e38b6e3d3bf02054a3357ea1a048275..16d35310670007c0599b50d18d43620a2d10524d 100644
--- a/daemon/src/media/video/video_device.h
+++ b/daemon/src/media/video/video_device.h
@@ -35,10 +35,10 @@
#include <memory>
#include <string>
#include <vector>
+#include "videomanager_interface.h"
namespace ring { namespace video {
-typedef std::map<std::string, std::map<std::string, std::vector<std::string>>> VideoCapabilities;
typedef std::map<std::string, std::string> VideoSettings;
// FIXME move VideoSettings in video_base since video_decoder (and encoder?) may use it.
@@ -73,7 +73,7 @@ public:
* '800x448': ['15'],
* '960x540': ['10']}}
*/
- VideoCapabilities getCapabilities() const;
+ DRing::VideoCapabilities getCapabilities() const;
/*
* Get the string/string map of settings for the device.
diff --git a/daemon/src/media/video/video_device_monitor.cpp b/daemon/src/media/video/video_device_monitor.cpp
index 3e1a450626070c398eaf4b1c398a22116aaaf2d2..87696d870a93c733d7282a39fbe9983402528e4d 100644
--- a/daemon/src/media/video/video_device_monitor.cpp
+++ b/daemon/src/media/video/video_device_monitor.cpp
@@ -37,6 +37,7 @@
#include "manager.h"
#include "client/videomanager.h"
+#include "client/signal.h"
#include "config/yamlparser.h"
#include "logger.h"
#include "video_device_monitor.h"
@@ -61,13 +62,13 @@ VideoDeviceMonitor::getDeviceList() const
return names;
}
-VideoCapabilities
+DRing::VideoCapabilities
VideoDeviceMonitor::getCapabilities(const string& name) const
{
const auto iter = findDeviceByName(name);
if (iter == devices_.end())
- return VideoCapabilities();
+ return DRing::VideoCapabilities();
return iter->getCapabilities();
}
@@ -158,8 +159,7 @@ notify()
RING_WARN("Manager not initialized yet");
return;
}
-
- Manager::instance().getVideoManager()->deviceEvent();
+ emitSignal<DRing::VideoSignal::DeviceEvent>();
}
void
diff --git a/daemon/src/media/video/video_device_monitor.h b/daemon/src/media/video/video_device_monitor.h
index 29b38de0a8830ee8874ed8c27b97e8ac0386b648..4faa1edb7737a18f2e6c3b6ddff5562e9c3a1aa9 100644
--- a/daemon/src/media/video/video_device_monitor.h
+++ b/daemon/src/media/video/video_device_monitor.h
@@ -58,7 +58,7 @@ class VideoDeviceMonitor : public Serializable
std::vector<std::string> getDeviceList() const;
- VideoCapabilities getCapabilities(const std::string& name) const;
+ DRing::VideoCapabilities getCapabilities(const std::string& name) const;
VideoSettings getSettings(const std::string& name);
void applySettings(const std::string& name, VideoSettings settings);
diff --git a/daemon/src/media/video/video_input.cpp b/daemon/src/media/video/video_input.cpp
index 6854db9452d05baf547a41053656223091e3639f..30ffd513ebcf2423bc1ad84f7f73c7d84206a5a5 100644
--- a/daemon/src/media/video/video_input.cpp
+++ b/daemon/src/media/video/video_input.cpp
@@ -37,6 +37,7 @@
#include "media_decoder.h"
#include "manager.h"
#include "client/videomanager.h"
+#include "client/signal.h"
#include "logger.h"
#include <map>
@@ -91,8 +92,8 @@ void VideoInput::process()
if (newDecoderCreated) {
/* Signal the client about the new sink */
- Manager::instance().getVideoManager()->startedDecoding(sinkID_, sink_.openedName(),
- decoder_->getWidth(), decoder_->getHeight(), false);
+ emitSignal<DRing::VideoSignal::DecodingStarted>(sinkID_, sink_.openedName(),
+ decoder_->getWidth(), decoder_->getHeight(), false);
RING_DBG("LOCAL: shm sink <%s> started: size = %dx%d",
sink_.openedName().c_str(), decoder_->getWidth(),
decoder_->getHeight());
@@ -176,9 +177,7 @@ VideoInput::deleteDecoder()
if (not decoder_)
return;
- Manager::instance().getVideoManager()->stoppedDecoding(sinkID_,
- sink_.openedName(),
- false);
+ emitSignal<DRing::VideoSignal::DecodingStopped>(sinkID_, sink_.openedName(), false);
flushFrames();
delete decoder_;
decoder_ = nullptr;
@@ -187,8 +186,7 @@ VideoInput::deleteDecoder()
bool
VideoInput::initCamera(const std::string& device)
{
- std::map<std::string, std::string> map =
- Manager::instance().getVideoManager()->getSettings(device);
+ std::map<std::string, std::string> map = DRing::getSettings(device);
if (map.empty())
return false;
diff --git a/daemon/src/media/video/video_mixer.cpp b/daemon/src/media/video/video_mixer.cpp
index ea7dbd86b246a7c84774978ad38525151a7fda5d..95a864c036c90d4f7ba088925e14763d985984b4 100644
--- a/daemon/src/media/video/video_mixer.cpp
+++ b/daemon/src/media/video/video_mixer.cpp
@@ -33,6 +33,7 @@
#include "video_mixer.h"
#include "logger.h"
#include "client/videomanager.h"
+#include "client/signal.h"
#include "manager.h"
#include "logger.h"
@@ -50,10 +51,9 @@ VideoMixer::VideoMixer(const std::string &id) :
, loop_([]{return true;}, std::bind(&VideoMixer::process, this), []{})
{
// Local video camera is the main participant
- auto videoCtrl = Manager::instance().getVideoManager();
- videoLocal_ = videoCtrl->getVideoCamera();
+ videoLocal_ = getVideoCamera();
if (videoLocal_) {
- videoCtrl->switchToCamera();
+ DRing::switchToCamera();
videoLocal_->attach(this);
}
loop_.start();
@@ -189,7 +189,7 @@ void VideoMixer::start_sink()
{
if (sink_.start()) {
if (this->attach(&sink_)) {
- Manager::instance().getVideoManager()->startedDecoding(id_, sink_.openedName(), width_, height_, true);
+ emitSignal<DRing::VideoSignal::DecodingStarted>(id_, sink_.openedName(), width_, height_, true);
RING_DBG("MX: shm sink <%s> started: size = %dx%d",
sink_.openedName().c_str(), width_, height_);
}
@@ -200,7 +200,7 @@ void VideoMixer::start_sink()
void VideoMixer::stop_sink()
{
if (this->detach(&sink_)) {
- Manager::instance().getVideoManager()->stoppedDecoding(id_, sink_.openedName(), true);
+ emitSignal<DRing::VideoSignal::DecodingStopped>(id_, sink_.openedName(), true);
sink_.stop();
}
}
diff --git a/daemon/src/media/video/video_receive_thread.cpp b/daemon/src/media/video/video_receive_thread.cpp
index 9cd8493a4e6321af72fbc98dc29239b1b87cab0b..75ffcc49a44235675ac18e6f6b6e3e61bff4a8ed 100644
--- a/daemon/src/media/video/video_receive_thread.cpp
+++ b/daemon/src/media/video/video_receive_thread.cpp
@@ -36,6 +36,7 @@
#include "manager.h"
#include "client/videomanager.h"
#include "logger.h"
+#include "client/signal.h"
#include <unistd.h>
#include <map>
@@ -149,7 +150,7 @@ void VideoReceiveThread::process()
void VideoReceiveThread::cleanup()
{
if (detach(&sink_))
- Manager::instance().getVideoManager()->stoppedDecoding(id_, sink_.openedName(), false);
+ emitSignal<DRing::VideoSignal::DecodingStopped>(id_, sink_.openedName(), false);
sink_.stop();
if (videoDecoder_)
@@ -223,7 +224,7 @@ void VideoReceiveThread::enterConference()
return;
if (detach(&sink_)) {
- Manager::instance().getVideoManager()->stoppedDecoding(id_, sink_.openedName(), false);
+ emitSignal<DRing::VideoSignal::DecodingStopped>(id_, sink_.openedName(), false);
RING_DBG("RX: shm sink <%s> detached", sink_.openedName().c_str());
}
}
@@ -235,7 +236,7 @@ void VideoReceiveThread::exitConference()
if (dstWidth_ > 0 && dstHeight_ > 0) {
if (attach(&sink_)) {
- Manager::instance().getVideoManager()->startedDecoding(id_, sink_.openedName(), dstWidth_, dstHeight_, false);
+ emitSignal<DRing::VideoSignal::DecodingStarted>(id_, sink_.openedName(), dstWidth_, dstHeight_, false);
RING_DBG("RX: shm sink <%s> started: size = %dx%d",
sink_.openedName().c_str(), dstWidth_, dstHeight_);
}
diff --git a/daemon/src/media/video/video_rtp_session.cpp b/daemon/src/media/video/video_rtp_session.cpp
index ea73d238299a1ec79d5fa8be9b87f8ae03046b38..61fd45a52bebf3ef47889c1feb6d36d1711c7711 100644
--- a/daemon/src/media/video/video_rtp_session.cpp
+++ b/daemon/src/media/video/video_rtp_session.cpp
@@ -189,10 +189,9 @@ void VideoRtpSession::start(int localPort)
if (conference_)
setupConferenceVideoPipeline(conference_);
else if (sender_) {
- auto videoCtrl = Manager::instance().getVideoManager();
- videoLocal_ = videoCtrl->getVideoCamera();
+ videoLocal_ = getVideoCamera();
if (videoLocal_ and videoLocal_->attach(sender_.get()))
- videoCtrl->switchToCamera();
+ DRing::switchToCamera();
} else {
videoLocal_.reset();
}
@@ -217,10 +216,9 @@ void VideoRtpSession::start(std::unique_ptr<IceSocket> rtp_sock,
if (conference_)
setupConferenceVideoPipeline(conference_);
else if (sender_) {
- auto videoCtrl = Manager::instance().getVideoManager();
- videoLocal_ = videoCtrl->getVideoCamera();
+ videoLocal_ = getVideoCamera();
if (videoLocal_ and videoLocal_->attach(sender_.get()))
- videoCtrl->switchToCamera();
+ DRing::switchToCamera();
} else {
videoLocal_.reset();
}
diff --git a/daemon/src/ring_api.cpp b/daemon/src/ring_api.cpp
index a58f2bfacdae37f276ab5a6f8477f2f12e5084b5..a7320b300f2c218aafc5bd915efb6038a8f4a15f 100644
--- a/daemon/src/ring_api.cpp
+++ b/daemon/src/ring_api.cpp
@@ -1,6 +1,7 @@
/*
- * Copyright (C) 2014 Savoir-Faire Linux Inc.
+ * Copyright (C) 2014-2015 Savoir-Faire Linux Inc.
* Author: Philippe Proulx <philippe.proulx@savoirfairelinux.com>
+ * Author: Guillaume Roguez <Guillaume.Roguez@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
@@ -36,58 +37,34 @@
#include "config.h"
#endif
+#include "libav_utils.h"
#include "manager.h"
#include "managerimpl.h"
#include "logger.h"
#include "dring.h"
-#include "client/callmanager.h"
-#include "client/configurationmanager.h"
-#include "client/presencemanager.h"
+#include "callmanager_interface.h"
+#include "configurationmanager_interface.h"
+#include "presencemanager_interface.h"
#ifdef RING_VIDEO
#include "client/videomanager.h"
#endif // RING_VIDEO
-static ring::CallManager* getCallManager()
-{
- return ring::Manager::instance().getCallManager();
-}
-
-static ring::ConfigurationManager* getConfigurationManager()
-{
- return ring::Manager::instance().getConfigurationManager();
-}
-
-static ring::PresenceManager* getPresenceManager()
-{
- return ring::Manager::instance().getPresenceManager();
-}
-
-#ifdef RING_VIDEO
-static ring::VideoManager* getVideoManager()
-{
- return ring::Manager::instance().getVideoManager();
-}
-#endif // RING_VIDEO
+namespace DRing {
-const char *
-ring_version()
+const char*
+version() noexcept
{
return PACKAGE_VERSION;
}
-int ring_init(ring_ev_handlers* ev_handlers, enum ring_init_flag flags)
+InitResult
+init(const std::map<EventHandlerKey, std::map<std::string, std::shared_ptr<CallbackWrapperBase>>>& ev_handlers,
+ enum InitFlag flags)
{
- // User handlers of library events
- // FIXME: static evil
- static ring_ev_handlers evHandlers_;
-
- // Copy user event handlers
- evHandlers_ = *ev_handlers;
-
// Handle flags
- setDebugMode(flags & RING_FLAG_DEBUG);
- setConsoleLog(flags & RING_FLAG_CONSOLE_LOG);
+ setDebugMode(flags & DRING_FLAG_DEBUG);
+ setConsoleLog(flags & DRING_FLAG_CONSOLE_LOG);
// Create manager
try {
@@ -97,673 +74,51 @@ int ring_init(ring_ev_handlers* ev_handlers, enum ring_init_flag flags)
assert(!manager);
manager = &(ring::Manager::instance());
} catch (...) {
- return -RING_ERR_MANAGER_INIT;
+ return InitResult::ERR_MANAGER_INIT;
}
+ ring::libav_utils::sfl_avcodec_init();
// Register user event handlers
- getCallManager()->registerEvHandlers(&evHandlers_.call_ev_handlers);
- getConfigurationManager()->registerEvHandlers(&evHandlers_.config_ev_handlers);
- getPresenceManager()->registerEvHandlers(&evHandlers_.pres_ev_handlers);
-
+ for ( const auto &entry : ev_handlers ) {
+ switch(entry.first) {
+ case EventHandlerKey::CALL:
+ ::DRing::registerCallHandlers(entry.second);
+ break;
+ case EventHandlerKey::CONFIG:
+ ::DRing::registerConfHandlers(entry.second);
+ break;
+ case EventHandlerKey::PRESENCE:
+ ::DRing::registerPresHandlers(entry.second);
+ break;
+ case EventHandlerKey::VIDEO:
#ifdef RING_VIDEO
- getVideoManager()->registerEvHandlers(&evHandlers_.video_ev_handlers);
-#endif // RING_VIDEO
+ ::DRing::registerVideoHandlers(entry.second);
+#else
+ RING_ERR("Error linking video handler: daemon has no video support");
+#endif
+ break;
+ }
+ }
// Initialize manager now
try {
ring::Manager::instance().init("");
} catch (...) {
- return -RING_ERR_MANAGER_INIT;
+ return InitResult::ERR_MANAGER_INIT;
}
- return 0;
+ return InitResult::SUCCESS;
}
-void ring_fini(void)
+void fini(void) noexcept
{
// Finish manager
ring::Manager::instance().finish();
}
-void ring_poll_events()
+void poll_events()
{
ring::Manager::instance().pollEvents();
}
-bool ring_call_place(const std::string& account_id, const std::string& call_id, const std::string& to)
-{
- return getCallManager()->placeCall(account_id, call_id, to);
-}
-
-bool ring_call_refuse(const std::string& call_id)
-{
- return getCallManager()->refuse(call_id);
-}
-
-bool ring_call_accept(const std::string& call_id)
-{
- return getCallManager()->accept(call_id);
-}
-
-bool ring_call_hang_up(const std::string& call_id)
-{
- return getCallManager()->hangUp(call_id);
-}
-
-bool ring_call_hold(const std::string& call_id)
-{
- return getCallManager()->hold(call_id);
-}
-
-bool ring_call_unhold(const std::string& call_id)
-{
- return getCallManager()->unhold(call_id);
-}
-
-bool ring_call_transfer(const std::string& call_id, const std::string& to)
-{
- return getCallManager()->transfer(call_id, to);
-}
-
-bool ring_call_attended_transfer(const std::string& transfer_id, const std::string& target_id)
-{
- return getCallManager()->attendedTransfer(transfer_id, target_id);
-}
-
-std::map<std::string, std::string> ring_call_get_call_details(const std::string& call_id)
-{
- return getCallManager()->getCallDetails(call_id);
-}
-
-std::vector<std::string> ring_call_get_call_list(void)
-{
- return getCallManager()->getCallList();
-}
-
-void ring_call_remove_conference(const std::string& conf_id)
-{
- getCallManager()->removeConference(conf_id);
-}
-
-bool ring_call_join_participant(const std::string& sel_call_id, const std::string& drag_call_id)
-{
- return getCallManager()->joinParticipant(sel_call_id, drag_call_id);
-}
-
-void ring_call_create_conf_from_participant_list(const std::vector<std::string>& participants)
-{
- getCallManager()->createConfFromParticipantList(participants);
-}
-
-bool ring_call_is_conference_participant(const std::string& call_id)
-{
- return getCallManager()->isConferenceParticipant(call_id);
-}
-
-bool ring_call_add_participant(const std::string& call_id, const std::string& conf_id)
-{
- return getCallManager()->addParticipant(call_id, conf_id);
-}
-
-bool ring_call_add_main_participant(const std::string& conf_id)
-{
- return getCallManager()->addMainParticipant(conf_id);
-}
-
-bool ring_call_detach_participant(const std::string& call_id)
-{
- return getCallManager()->detachParticipant(call_id);
-}
-
-bool ring_call_join_conference(const std::string& sel_conf_id, const std::string& drag_conf_id)
-{
- return getCallManager()->joinConference(sel_conf_id, drag_conf_id);
-}
-
-bool ring_call_hang_up_conference(const std::string& conf_id)
-{
- return getCallManager()->hangUpConference(conf_id);
-}
-
-bool ring_call_hold_conference(const std::string& conf_id)
-{
- return getCallManager()->holdConference(conf_id);
-}
-
-bool ring_call_unhold_conference(const std::string& conf_id)
-{
- return getCallManager()->unholdConference(conf_id);
-}
-
-std::vector<std::string> ring_call_get_conference_list(void)
-{
- return getCallManager()->getConferenceList();
-}
-
-std::vector<std::string> ring_call_get_participant_list(const std::string& conf_id)
-{
- return getCallManager()->getParticipantList(conf_id);
-}
-
-std::vector<std::string> ring_call_get_display_names(const std::string& conf_id)
-{
- return getCallManager()->getDisplayNames(conf_id);
-}
-
-std::string ring_call_get_conference_id(const std::string& call_id)
-{
- return getCallManager()->getConferenceId(call_id);
-}
-
-std::map<std::string, std::string> ring_call_get_conference_details(const std::string& call_id)
-{
- return getCallManager()->getConferenceDetails(call_id);
-}
-
-bool ring_call_play_recorded_file(const std::string& path)
-{
- return getCallManager()->startRecordedFilePlayback(path);
-}
-
-void ring_call_stop_recorded_file(const std::string& path)
-{
- getCallManager()->stopRecordedFilePlayback(path);
-}
-
-bool ring_call_toggle_recording(const std::string& call_id)
-{
- return getCallManager()->toggleRecording(call_id);
-}
-
-void ring_call_set_recording(const std::string& call_id)
-{
- getCallManager()->setRecording(call_id);
-}
-
-void ring_call_record_playback_seek(double pos)
-{
- getCallManager()->recordPlaybackSeek(pos);
-}
-
-bool ring_call_is_recording(const std::string& call_id)
-{
- return getCallManager()->getIsRecording(call_id);
-}
-
-std::string ring_call_get_current_audio_codec_name(const std::string& call_id)
-{
- return getCallManager()->getCurrentAudioCodecName(call_id);
-}
-
-void ring_call_play_dtmf(const std::string& key)
-{
- getCallManager()->playDTMF(key);
-}
-
-void ring_call_start_tone(int start, int type)
-{
- getCallManager()->startTone(start, type);
-}
-
-void ring_call_set_sas_verified(const std::string& call_id)
-{
- getCallManager()->setSASVerified(call_id);
-}
-
-void ring_call_reset_sas_verified(const std::string& call_id)
-{
- getCallManager()->resetSASVerified(call_id);
-}
-
-void ring_call_set_confirm_go_clear(const std::string& call_id)
-{
- getCallManager()->setConfirmGoClear(call_id);
-}
-
-void ring_call_request_go_clear(const std::string& call_id)
-{
- getCallManager()->requestGoClear(call_id);
-}
-
-void ring_call_accept_enrollment(const std::string& call_id, bool accepted)
-{
- getCallManager()->acceptEnrollment(call_id, accepted);
-}
-
-void ring_call_send_text_message(const std::string& call_id, const std::string& message)
-{
- getCallManager()->sendTextMessage(call_id, message);
-}
-
-std::map<std::string, std::string> ring_config_get_account_details(const std::string& account_id)
-{
- return getConfigurationManager()->getAccountDetails(account_id);
-}
-
-std::map<std::string, std::string> ring_config_get_volatile_account_details(const std::string& account_id)
-{
- return getConfigurationManager()->getVolatileAccountDetails(account_id);
-}
-
-void ring_config_set_account_details(const std::string& account_id, const std::map<std::string, std::string>& details)
-{
- getConfigurationManager()->setAccountDetails(account_id, details);
-}
-
-std::map<std::string, std::string> ring_config_get_account_template(void)
-{
- return getConfigurationManager()->getAccountTemplate();
-}
-
-std::string ring_config_add_account(const std::map<std::string, std::string>& details)
-{
- return getConfigurationManager()->addAccount(details);
-}
-
-void ring_config_remove_account(const std::string& account_id)
-{
- getConfigurationManager()->removeAccount(account_id);
-}
-
-std::vector<std::string> ring_config_get_account_list(void)
-{
- return getConfigurationManager()->getAccountList();
-}
-
-void ring_config_send_register(const std::string& account_id, bool enable)
-{
- getConfigurationManager()->sendRegister(account_id, enable);
-}
-
-void ring_config_register_all_accounts(void)
-{
- getConfigurationManager()->registerAllAccounts();
-}
-
-std::map<std::string, std::string> ring_config_get_tls_default_settings(void)
-{
- return getConfigurationManager()->getTlsSettingsDefault();
-}
-
-std::vector<int> ring_config_get_audio_codec_list(void)
-{
- return getConfigurationManager()->getAudioCodecList();
-}
-
-std::vector<std::string> ring_config_get_supported_tls_method(void)
-{
- return getConfigurationManager()->getSupportedTlsMethod();
-}
-
-std::vector<std::string> ring_config_get_supported_ciphers(const std::string& account_id)
-{
- return getConfigurationManager()->getSupportedCiphers(account_id);
-}
-
-std::vector<std::string> ring_config_get_audio_codec_details(int payload)
-{
- return getConfigurationManager()->getAudioCodecDetails(payload);
-}
-
-std::vector<int> ring_config_get_active_audio_codec_list(const std::string& account_id)
-{
- return getConfigurationManager()->getActiveAudioCodecList(account_id);
-}
-
-void ring_config_set_active_audio_codec_list(const std::vector<std::string>& list, const std::string& account_id)
-{
- getConfigurationManager()->setActiveAudioCodecList(list, account_id);
-}
-
-std::vector<std::string> ring_config_get_audio_plugin_list(void)
-{
- return getConfigurationManager()->getAudioPluginList();
-}
-
-void ring_config_set_audio_plugin(const std::string& audio_plugin)
-{
- getConfigurationManager()->setAudioPlugin(audio_plugin);
-}
-
-std::vector<std::string> ring_config_get_audio_output_device_list()
-{
- return getConfigurationManager()->getAudioOutputDeviceList();
-}
-
-void ring_config_set_audio_output_device(int index)
-{
- getConfigurationManager()->setAudioOutputDevice(index);
-}
-
-void ring_config_set_audio_input_device(int index)
-{
- getConfigurationManager()->setAudioInputDevice(index);
-}
-
-void ring_config_set_audio_ringtone_device(int index)
-{
- getConfigurationManager()->setAudioRingtoneDevice(index);
-}
-
-std::vector<std::string> ring_config_get_audio_input_device_list(void)
-{
- return getConfigurationManager()->getAudioInputDeviceList();
-}
-
-std::vector<std::string> ring_config_get_current_audio_devices_index(void)
-{
- return getConfigurationManager()->getCurrentAudioDevicesIndex();
-}
-
-int ring_config_get_audio_input_device_index(const std::string& name)
-{
- return getConfigurationManager()->getAudioInputDeviceIndex(name);
-}
-
-int ring_config_get_audio_output_device_index(const std::string& name)
-{
- return getConfigurationManager()->getAudioOutputDeviceIndex(name);
-}
-
-std::string ring_config_get_current_audio_output_plugin(void)
-{
- return getConfigurationManager()->getCurrentAudioOutputPlugin();
-}
-
-bool ring_config_get_noise_suppress_state(void)
-{
- return getConfigurationManager()->getNoiseSuppressState();
-}
-
-void ring_config_set_noise_suppress_state(bool state)
-{
- getConfigurationManager()->setNoiseSuppressState(state);
-}
-
-bool ring_config_is_agc_enabled(void)
-{
- return getConfigurationManager()->isAgcEnabled();
-}
-
-void ring_config_enable_agc(bool enabled)
-{
- getConfigurationManager()->setAgcState(enabled);
-}
-
-void ring_config_mute_dtmf(bool mute)
-{
- getConfigurationManager()->muteDtmf(mute);
-}
-
-bool ring_config_is_dtmf_muted(void)
-{
- return getConfigurationManager()->isDtmfMuted();
-}
-
-bool ring_config_is_capture_muted(void)
-{
- return getConfigurationManager()->isCaptureMuted();
-}
-
-void ring_config_mute_capture(bool mute)
-{
- getConfigurationManager()->muteCapture(mute);
-}
-
-bool ring_config_is_playback_muted(void)
-{
- return getConfigurationManager()->isPlaybackMuted();
-}
-
-void ring_config_mute_playback(int mute)
-{
- getConfigurationManager()->mutePlayback(mute);
-}
-
-std::string ring_config_get_audio_manager(void)
-{
- return getConfigurationManager()->getAudioManager();
-}
-
-bool ring_config_set_audio_manager(const std::string& api)
-{
- return getConfigurationManager()->setAudioManager(api);
-}
-
-std::vector<std::string> ring_config_get_supported_audio_managers(void)
-{
- return {
-#if HAVE_ALSA
- ALSA_API_STR,
-#endif
-#if HAVE_PULSE
- PULSEAUDIO_API_STR,
-#endif
-#if HAVE_JACK
- JACK_API_STR,
-#endif
- };
-}
-
-int ring_config_is_iax2_enabled(void)
-{
- return getConfigurationManager()->isIax2Enabled();
-}
-
-std::string ring_config_get_record_path(void)
-{
- return getConfigurationManager()->getRecordPath();
-}
-
-void ring_config_set_record_path(const std::string& path)
-{
- getConfigurationManager()->setRecordPath(path);
-}
-
-bool ring_config_is_always_recording(void)
-{
- return getConfigurationManager()->getIsAlwaysRecording();
-}
-
-void ring_config_set_always_recording(bool rec)
-{
- getConfigurationManager()->setIsAlwaysRecording(rec);
-}
-
-void ring_config_set_history_limit(int days)
-{
- getConfigurationManager()->setHistoryLimit(days);
-}
-
-int ring_config_get_history_limit(void)
-{
- return getConfigurationManager()->getHistoryLimit();
-}
-
-void ring_config_clear_history(void)
-{
- getConfigurationManager()->clearHistory();
-}
-
-void ring_config_set_accounts_order(const std::string& order)
-{
- getConfigurationManager()->setAccountsOrder(order);
-}
-
-std::map<std::string, std::string> ring_config_get_hook_settings(void)
-{
- return getConfigurationManager()->getHookSettings();
-}
-
-void ring_config_set_hook_settings(const std::map<std::string, std::string>& settings)
-{
- getConfigurationManager()->setHookSettings(settings);
-}
-
-std::vector<std::map<std::string, std::string>> ring_config_get_history(void)
-{
- return getConfigurationManager()->getHistory();
-}
-
-std::map<std::string, std::string> ring_config_get_tls_settings()
-{
- return getConfigurationManager()->getTlsSettings();
-}
-
-void ring_config_set_tls_settings(const std::map< std::string, std::string >& settings)
-{
- getConfigurationManager()->setTlsSettings(settings);
-}
-
-std::map<std::string, std::string> ring_config_get_ip2ip_details(void)
-{
- return getConfigurationManager()->getIp2IpDetails();
-}
-
-std::vector<std::map<std::string, std::string>> ring_config_get_credentials(const std::string& account_id)
-{
- return getConfigurationManager()->getCredentials(account_id);
-}
-
-void ring_config_set_credentials(const std::string& account_id, const std::vector<std::map<std::string, std::string>>& details)
-{
- getConfigurationManager()->setCredentials(account_id, details);
-}
-
-std::string ring_config_get_addr_from_interface_name(const std::string& interface)
-{
- return getConfigurationManager()->getAddrFromInterfaceName(interface);
-}
-
-std::vector<std::string> ring_config_get_all_ip_interface(void)
-{
- return getConfigurationManager()->getAllIpInterface();
-}
-
-std::vector<std::string> ring_config_get_all_ip_interface_by_name(void)
-{
- return getConfigurationManager()->getAllIpInterfaceByName();
-}
-
-std::map<std::string, std::string> ring_config_get_shortcuts()
-{
- return getConfigurationManager()->getShortcuts();
-}
-
-void ring_config_set_shortcuts(const std::map<std::string, std::string>& shortcuts)
-{
- getConfigurationManager()->setShortcuts(shortcuts);
-}
-
-void ring_config_set_volume(const std::string& device, double value)
-{
- getConfigurationManager()->setVolume(device, value);
-}
-
-double ring_config_get_volume(const std::string& device)
-{
- return getConfigurationManager()->getVolume(device);
-}
-
-std::map<std::string, std::string> ring_config_validate_certificate(const std::string& accountId, const std::string& certificate, const std::string& private_key)
-{
- return getConfigurationManager()->validateCertificate(accountId,certificate,private_key);
-}
-
-std::map<std::string, std::string> ring_config_get_certificate_details(const std::string& certificate)
-{
- return getConfigurationManager()->getCertificateDetails(certificate);
-}
-
-void ring_pres_publish(const std::string& account_id, int status, const std::string& note)
-{
- getPresenceManager()->publish(account_id, status, note);
-}
-
-void ring_pres_answer_server_request(const std::string& uri, int flag)
-{
- getPresenceManager()->answerServerRequest(uri, flag);
-}
-
-void ring_pres_subscribe_buddy(const std::string& account_id, const std::string& uri, int flag)
-{
- getPresenceManager()->subscribeBuddy(account_id, uri, flag);
-}
-
-std::vector<std::map<std::string, std::string>> ring_pres_get_subscriptions(const std::string& account_id)
-{
- return getPresenceManager()->getSubscriptions(account_id);
-}
-
-void ring_pres_set_subscriptions(const std::string& account_id, const std::vector<std::string>& uris)
-{
- getPresenceManager()->setSubscriptions(account_id, uris);
-}
-
-#ifdef RING_VIDEO
-std::vector<std::map<std::string, std::string>> ring_video_get_codecs(const std::string& account_id)
-{
- return getVideoManager()->getCodecs(account_id);
-}
-
-void ring_video_set_codecs(const std::string& account_id, const std::vector<std::map<std::string, std::string>>& details)
-{
- getVideoManager()->setCodecs(account_id, details);
-}
-
-std::vector<std::string> ring_video_get_device_list(void)
-{
- return getVideoManager()->getDeviceList();
-}
-
-std::map<std::string, std::string> ring_video_get_settings(const std::string& name)
-{
- return getVideoManager()->getSettings(name);
-}
-
-void ring_video_set_default_device(const std::string& dev)
-{
- getVideoManager()->setDefaultDevice(dev);
-}
-
-std::string ring_video_get_default_device(void)
-{
- return getVideoManager()->getDefaultDevice();
-}
-
-std::string ring_video_get_current_codec_name(const std::string& call_id)
-{
- return getVideoManager()->getCurrentCodecName(call_id);
-}
-
-void ring_video_start_camera(void)
-{
- getVideoManager()->startCamera();
-}
-
-void ring_video_stop_camera(void)
-{
- getVideoManager()->stopCamera();
-}
-
-bool ring_video_switch_input(const std::string& resource)
-{
- return getVideoManager()->switchInput(resource);
-}
-
-bool ring_video_is_camera_started(void)
-{
- return getVideoManager()->hasCameraStarted();
-}
-
-void ring_video_apply_settings(const std::string& name, const std::map<std::string, std::string>& settings)
-{
- getVideoManager()->applySettings(name, settings);
-}
-
-std::map<std::string, std::map<std::string, std::vector<std::string>>> ring_video_get_capabilities(const std::string& name)
-{
- return getVideoManager()->getCapabilities(name);
-}
-
-#endif // RING_VIDEO
+} // namespace DRing
diff --git a/daemon/src/ringdht/ringaccount.cpp b/daemon/src/ringdht/ringaccount.cpp
index 18a733098170f85ff692f791c150a9fdadec460a..277e7b20c9a3db7584faa9c032b386e7e6f0796a 100644
--- a/daemon/src/ringdht/ringaccount.cpp
+++ b/daemon/src/ringdht/ringaccount.cpp
@@ -47,7 +47,7 @@
#include "array_size.h"
-#include "client/configurationmanager.h"
+#include "client/signal.h"
#include "account_schema.h"
#include "logger.h"
diff --git a/daemon/src/sip/pres_sub_client.cpp b/daemon/src/sip/pres_sub_client.cpp
index 6f60e3d132725631c82515f1117f6229dad11129..c61a06d14da73688a9faa53f1004d7d4cf41dfd8 100644
--- a/daemon/src/sip/pres_sub_client.cpp
+++ b/daemon/src/sip/pres_sub_client.cpp
@@ -46,13 +46,12 @@
#include "array_size.h"
#include "pres_sub_client.h"
-#include "client/presencemanager.h"
-#include "client/configurationmanager.h"
#include "sipaccount.h"
#include "sippresence.h"
#include "sipvoiplink.h"
#include "sip_utils.h"
#include "manager.h"
+#include "client/signal.h"
#include "logger.h"
@@ -92,7 +91,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub *sub, pjsip_event *event)
if (state == PJSIP_EVSUB_STATE_ACCEPTED) {
pres_client->enable(true);
- Manager::instance().getPresenceManager()->subscriptionStateChanged(
+ emitSignal<DRing::PresenceSignal::SubscriptionStateChanged>(
pres->getAccount()->getAccountID(),
pres_client->getURI().c_str(),
PJ_TRUE);
@@ -103,7 +102,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub *sub, pjsip_event *event)
int resub_delay = -1;
pj_strdup_with_null(pres_client->pool_, &pres_client->term_reason_, pjsip_evsub_get_termination_reason(sub));
- Manager::instance().getPresenceManager()->subscriptionStateChanged(
+ emitSignal<DRing::PresenceSignal::SubscriptionStateChanged>(
pres->getAccount()->getAccountID(),
pres_client->getURI().c_str(),
PJ_FALSE);
@@ -162,7 +161,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub *sub, pjsip_event *event)
* 2) change the support field in the account schema if the pres_sub's server
* is the same as the account's server
*/
- Manager::instance().getPresenceManager()->serverError(
+ emitSignal<DRing::PresenceSignal::ServerError>(
pres_client->getPresence()->getAccount()->getAccountID(),
error,
msg);
diff --git a/daemon/src/sip/pres_sub_server.cpp b/daemon/src/sip/pres_sub_server.cpp
index 3908be50e9365ee9cf4303e88d87f3e4d3179351..6a5edf4c01272f85f46cf9dd1785d6e93df24608 100644
--- a/daemon/src/sip/pres_sub_server.cpp
+++ b/daemon/src/sip/pres_sub_server.cpp
@@ -36,9 +36,9 @@
#include "sipvoiplink.h"
#include "manager.h"
#include "sippresence.h"
-#include "client/presencemanager.h"
#include "logger.h"
#include "pres_sub_server.h"
+#include "client/signal.h"
namespace ring {
@@ -188,8 +188,7 @@ PresSubServer::pres_on_rx_subscribe_request(pjsip_rx_data *rdata)
PresSubServer *presSubServer = new PresSubServer(pres, sub, remote, dlg);
pjsip_evsub_set_mod_data(sub, pres->getModId(), presSubServer);
// Notify the client.
- Manager::instance().getPresenceManager()->newServerSubscriptionRequest(presSubServer->remote_);
-
+ emitSignal<DRing::PresenceSignal::NewServerSubscriptionRequest>(presSubServer->remote_);
pres->addPresSubServer(presSubServer);
/* Capture the value of Expires header. */
diff --git a/daemon/src/sip/sipaccount.cpp b/daemon/src/sip/sipaccount.cpp
index 0caf57a71585807ba49ebe8a89e0cd46f4f98d2c..ea6fb2889799090f6e9048db1e7c0f9fcb6142c3 100644
--- a/daemon/src/sip/sipaccount.cpp
+++ b/daemon/src/sip/sipaccount.cpp
@@ -48,7 +48,6 @@
#include "call_factory.h"
#include "sippresence.h"
-#include "client/configurationmanager.h"
#include <yaml-cpp/yaml.h>
@@ -56,6 +55,7 @@
#include "config/yamlparser.h"
#include "logger.h"
#include "manager.h"
+#include "client/signal.h"
#ifdef RING_VIDEO
#include "libav_utils.h"
@@ -1132,8 +1132,8 @@ SIPAccount::onRegister(pjsip_regc_cbparam *param)
if (param->code && description) {
std::string state(description->ptr, description->slen);
- Manager::instance().getConfigurationManager()->sipRegistrationStateChanged(getAccountID(), state, param->code);
- Manager::instance().getConfigurationManager()->volatileAccountDetailsChanged(accountID_, getVolatileAccountDetails());
+ emitSignal<DRing::ConfigurationSignal::SipRegistrationStateChanged>(getAccountID(), state, param->code);
+ emitSignal<DRing::ConfigurationSignal::VolatileDetailsChanged>(accountID_, getVolatileAccountDetails());
std::pair<int, std::string> details(param->code, state);
// TODO: there id a race condition for this ressource when closing the application
setRegistrationStateDetailed(details);
@@ -1841,7 +1841,7 @@ SIPAccount::supportPresence(int function, bool enabled)
enablePresence(false);
Manager::instance().saveConfig();
- Manager::instance().getConfigurationManager()->accountsChanged();
+ emitSignal<DRing::ConfigurationSignal::AccountsChanged>();
}
MatchRank
diff --git a/daemon/src/sip/sipaccountbase.cpp b/daemon/src/sip/sipaccountbase.cpp
index 868ae10c9ca92ba062c2cf722d7b1c086daf77da..880b1050071466de6c22c5ad6cb2fda61473d3ca 100644
--- a/daemon/src/sip/sipaccountbase.cpp
+++ b/daemon/src/sip/sipaccountbase.cpp
@@ -37,12 +37,13 @@
#endif
#include "account_schema.h"
-#include "client/configurationmanager.h"
#include "manager.h"
#include "config/yamlparser.h"
#include <yaml-cpp/yaml.h>
+#include "client/signal.h"
+
namespace ring {
bool SIPAccountBase::portsInUse_[HALF_MAX_PORT];
@@ -277,7 +278,7 @@ SIPAccountBase::onTransportStateChanged(pjsip_transport_state state, const pjsip
// Notify the client of the new transport state
if (currentStatus != transportStatus_)
- Manager::instance().getConfigurationManager()->volatileAccountDetailsChanged(accountID_, getVolatileAccountDetails());
+ emitSignal<DRing::ConfigurationSignal::VolatileDetailsChanged>(accountID_, getVolatileAccountDetails());
}
void
diff --git a/daemon/src/sip/sipcall.cpp b/daemon/src/sip/sipcall.cpp
index 11027bee8051d37714036283514dd6a2b8d5a04f..b43eee0c482549320902162080d39a486c9c85e5 100644
--- a/daemon/src/sip/sipcall.cpp
+++ b/daemon/src/sip/sipcall.cpp
@@ -3,8 +3,8 @@
* Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
* Author: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
* Author: Yan Morin <yan.morin@savoirfairelinux.com>
- * Author : Laurielle Lea <laurielle.lea@savoirfairelinux.com>
- * Author : Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
+ * Author: Laurielle Lea <laurielle.lea@savoirfairelinux.com>
+ * Author: Guillaume Roguez <guillaume.roguez@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
@@ -45,7 +45,6 @@
#include "upnp/upnp_control.h"
#include "audio/audiortp/avformat_rtp_session.h"
-#include "client/callmanager.h"
#if HAVE_INSTANT_MESSAGING
#include "im/instant_messaging.h"
@@ -53,21 +52,12 @@
#ifdef RING_VIDEO
#include "video/video_rtp_session.h"
-#include "client/videomanager.h"
+#include "dring/videomanager_interface.h"
#include <chrono>
#endif
namespace ring {
-#ifdef RING_VIDEO
-static video::VideoSettings
-getSettings()
-{
- const auto videoman = Manager::instance().getVideoManager();
- return videoman->getSettings(videoman->getDefaultDevice());
-}
-#endif
-
static constexpr int DEFAULT_ICE_INIT_TIMEOUT {10}; // seconds
static constexpr int DEFAULT_ICE_NEGO_TIMEOUT {60}; // seconds
@@ -123,7 +113,7 @@ SIPCall::SIPCall(SIPAccountBase& account, const std::string& id, Call::CallType
, avformatrtp_(new AVFormatRtpSession(id, *new std::map<std::string, std::string>))
#ifdef RING_VIDEO
// The ID is used to associate video streams to calls
- , videortp_(id, getSettings())
+ , videortp_(id, ::DRing::getSettings(DRing::getDefaultDevice()))
#endif
, sdp_(new Sdp(id))
{
diff --git a/daemon/src/sip/sippresence.cpp b/daemon/src/sip/sippresence.cpp
index 222ed6e4fea9750ec8ef1176cce64994ac0a683d..bf5201741ef1315fcbf1a0f744f3de642b4e2441 100644
--- a/daemon/src/sip/sippresence.cpp
+++ b/daemon/src/sip/sippresence.cpp
@@ -35,13 +35,12 @@
#include <sstream>
#include "logger.h"
#include "manager.h"
-#include "client/presencemanager.h"
-#include "client/configurationmanager.h"
#include "sipaccount.h"
#include "sip_utils.h"
#include "pres_sub_server.h"
#include "pres_sub_client.h"
#include "sipvoiplink.h"
+#include "client/signal.h"
#define MAX_N_SUB_SERVER 50
#define MAX_N_SUB_CLIENT 50
@@ -205,7 +204,7 @@ void SIPPresence::reportPresSubClientNotification(const std::string& uri, pjsip_
note_ = note;
}
// report status to client signal
- Manager::instance().getPresenceManager()->newBuddyNotification(acc_ID, uri, status->info[0].basic_open, note);
+ emitSignal<DRing::PresenceSignal::NewBuddyNotification>(acc_ID, uri, status->info[0].basic_open, note);
}
void SIPPresence::subscribeClient(const std::string& uri, bool flag)
@@ -381,7 +380,7 @@ SIPPresence::publish_cb(struct pjsip_publishc_cbparam *param)
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(param->status, errmsg, sizeof(errmsg));
RING_ERR("Client (PUBLISH) failed, status=%d, msg=%s", param->status, errmsg);
- Manager::instance().getPresenceManager()->serverError(
+ emitSignal<DRing::PresenceSignal::ServerError>(
pres->getAccount()->getAccountID(),
error,
errmsg);
@@ -395,7 +394,7 @@ SIPPresence::publish_cb(struct pjsip_publishc_cbparam *param)
} else if ((param->code == PJSIP_SC_BAD_EVENT) || (param->code == PJSIP_SC_NOT_IMPLEMENTED)){ //489 or 501
RING_WARN("Client (PUBLISH) failed (%s)",error.c_str());
- Manager::instance().getPresenceManager()->serverError(
+ emitSignal<DRing::PresenceSignal::ServerError>(
pres->getAccount()->getAccountID(),
error,
"Publish not supported.");
diff --git a/daemon/src/sip/siptransport.cpp b/daemon/src/sip/siptransport.cpp
index fa1491c9a5b09e7ee333c4bb40103461b4b3d7fc..68c0a959ba6d24d4e9b35d36120efd28db267063 100644
--- a/daemon/src/sip/siptransport.cpp
+++ b/daemon/src/sip/siptransport.cpp
@@ -36,7 +36,6 @@
#include "ringdht/sip_transport_ice.h"
-#include "client/configurationmanager.h"
#include "array_size.h"
#include "intrin.h"
#include "sipvoiplink.h"
diff --git a/daemon/src/sip/sipvoiplink.cpp b/daemon/src/sip/sipvoiplink.cpp
index b7b78398076e9dad7be0cd6dd6f873e51fbcb230..7ec1d6c702687eb7b7589449823c6fc914871d84 100644
--- a/daemon/src/sip/sipvoiplink.cpp
+++ b/daemon/src/sip/sipvoiplink.cpp
@@ -4,7 +4,7 @@
* Author: Yun Liu <yun.liu@savoirfairelinux.com>
* Author: Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com>
* Author: Alexandre Savard <alexandre.savard@savoirfairelinux.com>
- * Author : Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
+ * Author: Guillaume Roguez <guillaume.roguez@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
@@ -62,8 +62,7 @@
#include "client/videomanager.h"
#endif
-#include "client/callmanager.h"
-#include "client/configurationmanager.h"
+#include "client/signal.h"
#include "pres_sub_server.h"
@@ -818,8 +817,7 @@ invite_session_state_changed_cb(pjsip_inv_session *inv, pjsip_event *ev)
const pj_str_t * description = pjsip_get_status_text(statusCode);
std::string desc(description->ptr, description->slen);
- CallManager *cm = Manager::instance().getCallManager();
- cm->sipCallStateChanged(call->getCallId(), desc, statusCode);
+ emitSignal<DRing::CallSignal::SipCallStateChanged>(call->getCallId(), desc, statusCode);
}
}
diff --git a/daemon/test/accounttest.cpp b/daemon/test/accounttest.cpp
index 39f7a27bdf045f8dab4dc7a3438f28dd09610d8c..e8c359c7bf8754649fa279e7ff9011b8486ff912 100644
--- a/daemon/test/accounttest.cpp
+++ b/daemon/test/accounttest.cpp
@@ -30,11 +30,12 @@
#include <cppunit/extensions/HelperMacros.h>
#include <map>
+
#include "account.h"
#include "account_schema.h"
#include "accounttest.h"
#include "manager.h"
-#include "client/configurationmanager.h"
+#include "configurationmanager_interface.h"
#include "logger.h"
namespace ring { namespace test {
@@ -43,18 +44,17 @@ void AccountTest::TestAddRemove()
{
RING_DBG("-------------------- %s --------------------\n", __PRETTY_FUNCTION__);
- std::map<std::string, std::string> details(Manager::instance().getConfigurationManager()->getAccountTemplate());
+ auto details = DRing::getAccountTemplate();
details[Conf::CONFIG_ACCOUNT_TYPE] = "SIP";
details[Conf::CONFIG_ACCOUNT_ENABLE] = "false";
details[Conf::CONFIG_LOCAL_INTERFACE] = "default";
details[Conf::CONFIG_LOCAL_PORT] = "5060";
- std::string accountId = Manager::instance().addAccount(details);
+ auto accountId = Manager::instance().addAccount(details);
CPPUNIT_ASSERT(not accountId.empty());
CPPUNIT_ASSERT(Manager::instance().hasAccount(accountId));
Manager::instance().removeAccount(accountId);
-
CPPUNIT_ASSERT(!Manager::instance().hasAccount(accountId));
}