jami/jami-daemon
1
0
Fork 0
mirror of https://git.jami.net/savoirfairelinux/jami-daemon.git synced 2025-08-12 22:09:25 +08:00
Code Issues Projects Releases Wiki Activity

plugins: add callId to API

Browse Source 
Change-Id: I2b59205b9ad2f75c6c8602a5a273a7d8115e5db6
This commit is contained in:
agsantos
2020-10-23 18:57:00 -04:00
committed by Adrien Béraud
parent 75ec461623
commit 69f559976e
11 changed files with 100 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
bin/dbus/cx.ring.Ring.PluginManagerInterface.xml
View File

@ -115,7 +115,9 @@
<method name="toggleCallMediaHandler" tp:name-for-bindings="toggleCallMediaHandler">
<tp:added version="9.2.0"/>
<arg type="s" name="id" direction="in">
<arg type="s" name="mediaHandlerId" direction="in">
</arg>
<arg type="s" name="callId" direction="in">
</arg>
<arg type="b" name="toggle" direction="in">
</arg>
@ -124,7 +126,7 @@
<method name="getCallMediaHandlerDetails" tp:name-for-bindings="getCallMediaHandlerDetails">
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringString"/>
<tp:added version="9.2.0"/>
<arg type="s" name="id" direction="in">
<arg type="s" name="mediaHandlerId" direction="in">
</arg>
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringString"/>
<arg type="a{ss}" name="CallMediaHandlerDetails" direction="out">
@ -147,10 +149,12 @@
</method>
<method name="getCallMediaHandlerStatus" tp:name-for-bindings="getCallMediaHandlerStatus">
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringString"/>
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringVectorString"/>
<tp:added version="9.3.0"/>
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringString"/>
<arg type="a{ss}" name="getCallMediaHandlerStatus" direction="out">
<arg type="s" name="callId" direction="in">
</arg>
<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="MapStringVectorString"/>
<arg type="a{sas}" name="getCallMediaHandlerStatus" direction="out">
</arg>
</method>

16
bin/dbus/dbuspluginmanagerinterface.cpp
View File

@ -106,15 +106,17 @@ DBusPluginManagerInterface::listCallMediaHandlers() -> decltype(DRing::listCallM
}
void
DBusPluginManagerInterface::toggleCallMediaHandler(const std::string& id, const bool& toggle)
DBusPluginManagerInterface::toggleCallMediaHandler(const std::string& mediaHandlerId,
const std::string& callId,
const bool& toggle)
{
DRing::toggleCallMediaHandler(id, toggle);
DRing::toggleCallMediaHandler(mediaHandlerId, callId, toggle);
}
std::map<std::string, std::string>
DBusPluginManagerInterface::getCallMediaHandlerDetails(const std::string& id)
DBusPluginManagerInterface::getCallMediaHandlerDetails(const std::string& mediaHanlderId)
{
return DRing::getCallMediaHandlerDetails(id);
return DRing::getCallMediaHandlerDetails(mediaHanlderId);
}
bool
@ -129,8 +131,8 @@ DBusPluginManagerInterface::setPluginsEnabled(const bool& state)
DRing::setPluginsEnabled(state);
}
std::map<std::string, std::string>
DBusPluginManagerInterface::getCallMediaHandlerStatus()
std::map<std::string, std::vector<std::string>>
DBusPluginManagerInterface::getCallMediaHandlerStatus(const std::string& callId)
{
return DRing::getCallMediaHandlerStatus();
return DRing::getCallMediaHandlerStatus(callId);
}

9
bin/dbus/dbuspluginmanagerinterface.h
View File

@ -67,10 +67,13 @@ public:
int installPlugin(const std::string& jplPath, const bool& force);
int uninstallPlugin(const std::string& pluginRootPath);
std::vector<std::string> listCallMediaHandlers();
void toggleCallMediaHandler(const std::string& id, const bool& toggle);
std::map<std::string, std::string> getCallMediaHandlerDetails(const std::string& id);
void toggleCallMediaHandler(const std::string& mediaHandlerId,
const std::string& callId,
const bool& toggle);
std::map<std::string, std::string> getCallMediaHandlerDetails(const std::string& mediaHandlerId);
bool getPluginsEnabled();
void setPluginsEnabled(const bool& state);
std::map<std::string, std::string> getCallMediaHandlerStatus();
std::map<std::string, std::vector<std::string>> getCallMediaHandlerStatus(
const std::string& callId);
};

6
bin/jni/plugin_manager_interface.i
View File

@ -37,9 +37,9 @@ std::vector<std::string> listLoadedPlugins();
int installPlugin(const std::string& jplPath, bool force);
int uninstallPlugin(const std::string& pluginRootPath);
std::vector<std::string> listCallMediaHandlers();
void toggleCallMediaHandler(const std::string& id, bool toggle);
std::map<std::string,std::string> getCallMediaHandlerDetails(const std::string& id);
void toggleCallMediaHandler(const std::string& mediaHandlerId, const std::string& callId, bool toggle);
std::map<std::string,std::string> getCallMediaHandlerDetails(const std::string& mediaHandlerId);
bool getPluginsEnabled();
void setPluginsEnabled(bool state);
std::map<std::string,std::string> getCallMediaHandlerStatus();
std::map<std::string, std::vector<std::string>> getCallMediaHandlerStatus(const std::string& callId);
}

2
meson.build
View File

@ -1,5 +1,5 @@
project('jami-daemon', ['c', 'cpp'],
version: '9.5.0',
version: '9.6.0',
license: 'GPL3+',
default_options: ['cpp_std=gnu++17', 'buildtype=debugoptimized'],
meson_version:'>= 0.54'

14
src/client/plugin_manager_interface.cpp
View File

@ -114,21 +114,21 @@ listCallMediaHandlers()
}
void
toggleCallMediaHandler(const std::string& id, bool toggle)
toggleCallMediaHandler(const std::string& mediaHandlerId, const std::string& callId, bool toggle)
{
return jami::Manager::instance()
.getJamiPluginManager()
.getCallServicesManager()
.toggleCallMediaHandler(id, toggle);
.toggleCallMediaHandler(mediaHandlerId, callId, toggle);
}
std::map<std::string, std::string>
getCallMediaHandlerDetails(const std::string& id)
getCallMediaHandlerDetails(const std::string& mediaHandlerId)
{
return jami::Manager::instance()
.getJamiPluginManager()
.getCallServicesManager()
.getCallMediaHandlerDetails(id);
.getCallMediaHandlerDetails(mediaHandlerId);
}
bool
@ -144,12 +144,12 @@ setPluginsEnabled(bool state)
jami::Manager::instance().saveConfig();
}
std::map<std::string, std::string>
getCallMediaHandlerStatus()
std::map<std::string, std::vector<std::string>>
getCallMediaHandlerStatus(const std::string& callId)
{
return jami::Manager::instance()
.getJamiPluginManager()
.getCallServicesManager()
.getCallMediaHandlerStatus();
.getCallMediaHandlerStatus(callId);
}
} // namespace DRing

11
src/dring/plugin_manager_interface.h
View File

@ -27,6 +27,7 @@
#include <string>
#include <vector>
#include <map>
#include <list>
#if __APPLE__
#import "TargetConditionals.h"
@ -49,9 +50,13 @@ DRING_PUBLIC std::vector<std::string> listLoadedPlugins();
DRING_PUBLIC int installPlugin(const std::string& jplPath, bool force);
DRING_PUBLIC int uninstallPlugin(const std::string& pluginRootPath);
DRING_PUBLIC std::vector<std::string> listCallMediaHandlers();
DRING_PUBLIC void toggleCallMediaHandler(const std::string& id, bool toggle);
DRING_PUBLIC std::map<std::string, std::string> getCallMediaHandlerDetails(const std::string& id);
DRING_PUBLIC void toggleCallMediaHandler(const std::string& mediaHandlerId,
const std::string& callId,
bool toggle);
DRING_PUBLIC std::map<std::string, std::string> getCallMediaHandlerDetails(
const std::string& mediaHandlerId);
DRING_PUBLIC bool getPluginsEnabled();
DRING_PUBLIC void setPluginsEnabled(bool state);
DRING_PUBLIC std::map<std::string, std::string> getCallMediaHandlerStatus();
DRING_PUBLIC std::map<std::string, std::vector<std::string>> getCallMediaHandlerStatus(
const std::string& callId);
} // namespace DRing

135
src/plugin/callservicesmanager.h
View File

@ -29,6 +29,8 @@
#include "mediahandler.h"
// STL
#include <list>
#include <set>
#include <tuple>
namespace jami {
using MediaHandlerPtr = std::unique_ptr<MediaHandler>;
@ -48,24 +50,6 @@ public:
NON_COPYABLE(CallServicesManager);
public:
/**
* @brief notifyAllAVSubject
* @param subject
* @param av
* @param local
* @param peerId
* This function is called whenever there is a new AVFrame subject available
*/
void notifyAllAVSubject(const StreamData& data, AVSubjectSPtr& subject)
{
for (auto& pair : callMediaHandlers) {
auto& callMediaHandlerPtr = pair.second;
if (pair.first) {
notifyAVSubject(callMediaHandlerPtr, data, subject);
}
}
}
/**
* @brief createAVSubject
* @param data
@ -75,24 +59,20 @@ public:
{
// This guarantees unicity of subjects by id
callAVsubjects.push_back(std::make_pair(data, subject));
for (const auto& toggledMediaHandler : mediaHandlerToggled_[data.id]) {
toggleCallMediaHandler(toggledMediaHandler, data.id, true);
}
}
void clearAVSubject(const std::string& callID)
void clearAVSubject(const std::string& callId)
{
for (auto it = callAVsubjects.begin(); it != callAVsubjects.end();) {
if (it->first.id == callID) {
if (it->first.id == callId) {
it = callAVsubjects.erase(it);
} else {
++it;
}
}
for (auto& callMediaHandler : callMediaHandlers) {
if (mediaHandlerToggled_[getCallHandlerId(callMediaHandler.second)] == callID) {
callMediaHandler.first = false;
callMediaHandler.second->detach();
mediaHandlerToggled_[getCallHandlerId(callMediaHandler.second)] = "";
}
}
}
/**
@ -105,14 +85,14 @@ public:
CallMediaHandlerPtr ptr {(static_cast<CallMediaHandler*>(data))};
if (ptr) {
callMediaHandlers.push_back(std::make_pair(false, std::move(ptr)));
callMediaHandlers.emplace_back(std::move(ptr));
}
return 0;
};
auto unregisterMediaHandler = [this](void* data) {
for (auto it = callMediaHandlers.begin(); it != callMediaHandlers.end(); ++it) {
if (it->second.get() == data) {
if (it->get() == data) {
callMediaHandlers.erase(it);
break;
}
@ -133,10 +113,8 @@ public:
std::vector<std::string> listCallMediaHandlers()
{
std::vector<std::string> res;
for (const auto& pair : callMediaHandlers) {
if (pair.second) {
res.push_back(getCallHandlerId(pair.second));
}
for (const auto& mediaHandler : callMediaHandlers) {
res.emplace_back(getCallHandlerId(mediaHandler));
}
return res;
}
@ -147,36 +125,31 @@ public:
* if off, detach it
* @param id
*/
void toggleCallMediaHandler(const std::string& id, const bool toggle)
void toggleCallMediaHandler(const std::string& mediaHandlerId,
const std::string& callId,
const bool toggle)
{
std::string callID = Manager::instance().getCurrentCallId();
if (toggle) {
for (auto& pair : mediaHandlerToggled_) {
if (pair.second == callID && pair.first != id) {
toggleCallMediaHandler(pair.first, false);
}
}
}
if (id.empty())
if (mediaHandlerId.empty())
return;
auto find = mediaHandlerToggled_.find(id);
auto find = mediaHandlerToggled_.find(callId);
if (find == mediaHandlerToggled_.end())
mediaHandlerToggled_[id] = "";
mediaHandlerToggled_[callId] = {};
for (auto it = callAVsubjects.begin(); it != callAVsubjects.end(); ++it) {
if (it->first.id == callID) {
for (auto& pair : callMediaHandlers) {
if (pair.second && getCallHandlerId(pair.second) == id) {
pair.first = toggle;
if (pair.first) {
mediaHandlerToggled_[id] = callID;
listAvailableSubjects(callID, pair.second);
if (it->first.id == callId) {
for (auto& mediaHandler : callMediaHandlers) {
if (getCallHandlerId(mediaHandler) == mediaHandlerId) {
if (toggle) {
if (mediaHandlerToggled_[callId].find(mediaHandlerId)
== mediaHandlerToggled_[callId].end())
mediaHandlerToggled_[callId].insert(mediaHandlerId);
listAvailableSubjects(callId, mediaHandler);
} else {
pair.second->detach();
mediaHandlerToggled_[id] = "";
mediaHandler->detach();
if (mediaHandlerToggled_[callId].find(mediaHandlerId)
!= mediaHandlerToggled_[callId].end())
mediaHandlerToggled_[callId].erase(mediaHandlerId);
}
}
}
@ -189,34 +162,36 @@ public:
* @param id of the call media handler
* @return map of Call Media Handler Details
*/
std::map<std::string, std::string> getCallMediaHandlerDetails(const std::string& id)
std::map<std::string, std::string> getCallMediaHandlerDetails(const std::string& mediaHandlerId)
{
for (auto& pair : callMediaHandlers) {
if (pair.second && getCallHandlerId(pair.second) == id) {
return pair.second->getCallMediaHandlerDetails();
for (auto& mediaHandler : callMediaHandlers) {
if (getCallHandlerId(mediaHandler) == mediaHandlerId) {
return mediaHandler->getCallMediaHandlerDetails();
}
}
return {};
}
std::map<std::string, std::string> getCallMediaHandlerStatus()
std::map<std::string, std::vector<std::string>> getCallMediaHandlerStatus(
const std::string& callId)
{
for (auto& pair : mediaHandlerToggled_) {
if (pair.second == Manager::instance().getCurrentCallId()) {
return {{"name", pair.first}};
}
const auto& it = mediaHandlerToggled_.find(callId);
if (it != mediaHandlerToggled_.end()) {
std::vector<std::string> ret;
for (const auto& mediaHandlerId : it->second)
ret.push_back(mediaHandlerId);
return {{callId, ret}};
}
return {{"name", ""}};
return {{callId, {}}};
}
void setPreference(const std::string& key, const std::string& value, const std::string& scopeStr)
{
for (auto& pair : callMediaHandlers) {
if (pair.second
&& scopeStr.find(pair.second->getCallMediaHandlerDetails()["name"])
!= std::string::npos) {
pair.second->setPreferenceAttribute(key, value);
for (auto& mediaHandler : callMediaHandlers) {
if (scopeStr.find(mediaHandler->getCallMediaHandlerDetails()["name"])
!= std::string::npos) {
mediaHandler->setPreferenceAttribute(key, value);
}
}
}
@ -237,19 +212,6 @@ private:
}
}
void cleanCallAVSubjects()
{
// remove subjects from not available calls callAVsubjects
for (auto it = callAVsubjects.begin(); it != callAVsubjects.end();) {
std::vector<std::string> callids = jami::Manager::instance().getCallList();
if (std::find(callids.begin(), callids.end(), it->first.id) == callids.end()) {
it = callAVsubjects.erase(it);
} else {
++it;
}
}
}
/**
* @brief listAvailableSubjects
* @param callMediaHandlerPtr
@ -286,7 +248,7 @@ private:
* These objects can then be notified with notify notifyAVFrameSubject
* whenever there is a new CallAVSubject like a video receive
*/
std::list<std::pair<bool, CallMediaHandlerPtr>> callMediaHandlers;
std::list<CallMediaHandlerPtr> callMediaHandlers;
/**
* @brief callAVsubjects
@ -296,8 +258,9 @@ private:
* It is pushed to this list list
*/
std::list<std::pair<const StreamData, AVSubjectSPtr>> callAVsubjects;
// std::map<std::string, std::tuple<const StreamData, AVSubjectSPtr>> callAVsubjects;
std::map<std::string, std::string> mediaHandlerToggled_;
std::map<std::string, std::set<std::string>> mediaHandlerToggled_;
};
} // namespace jami

1
src/plugin/jamipluginmanager.h
View File

@ -30,6 +30,7 @@
#include <vector>
#include <map>
#include <list>
#include <string>
#include <algorithm>

10
src/sip/sipcall.cpp
View File

@ -161,13 +161,13 @@ SIPCall::createCallAVStream(const StreamData& StreamData,
MediaStream& streamSource,
const std::shared_ptr<MediaStreamSubject>& mediaStreamSubject)
{
callAVStreams.push_back(mediaStreamSubject);
auto& inserted = callAVStreams.back();
streamSource.attachPriorityObserver(inserted);
const std::string AVStreamId = StreamData.id + std::to_string(StreamData.direction);
callAVStreams[AVStreamId] = mediaStreamSubject;
streamSource.attachPriorityObserver(callAVStreams[AVStreamId]);
jami::Manager::instance()
.getJamiPluginManager()
.getCallServicesManager()
.createAVSubject(StreamData, inserted);
.createAVSubject(StreamData, callAVStreams[AVStreamId]);
}
#endif // ENABLE_PLUGIN
@ -1250,6 +1250,8 @@ SIPCall::stopAllMedia()
videortp_->stop();
#endif
#ifdef ENABLE_PLUGIN
callAVStreams.erase(getCallId() + "0");
callAVStreams.erase(getCallId() + "1");
jami::Manager::instance().getJamiPluginManager().getCallServicesManager().clearAVSubject(
getCallId());
#endif

2
src/sip/sipcall.h
View File

@ -279,7 +279,7 @@ private:
void createCallAVStreams();
#endif // ENABLE_PLUGIN
std::list<std::shared_ptr<MediaStreamSubject>> callAVStreams;
std::map<std::string, std::shared_ptr<MediaStreamSubject>> callAVStreams;
void setCallMediaLocal();