lilith/jami-client-qt
1
0
Fork 0
mirror of https://git.jami.net/savoirfairelinux/jami-client-qt.git synced 2025-04-21 21:52:03 +02:00
Code Activity

misc: rename DRing->libjami

Browse source 
Change-Id: I15d382406687cc506c1456ce43286ad6b0f23529
This commit is contained in:
Sébastien Blin 2022-10-25 13:28:17 -04:00
parent c6f2293ce3
commit 90ae50ee5f
27 changed files with 674 additions and 641 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
extras/scripts/run-tests.sh
View file

@ -19,8 +19,8 @@ mkdir -p build
cd build
echo "Building lrc in "$PWD
cmake .. -DCMAKE_INSTALL_PREFIX=$installDir/lrc \
-DRING_INCLUDE_DIR=$daemonDir/src/jami \
-DRING_XML_INTERFACES_DIR=$daemonDir/bin/dbus
-LIBJAMI_INCLUDE_DIR=$daemonDir/src/jami \
-LIBJAMI_XML_INTERFACES_DIR=$daemonDir/bin/dbus
make -j${cpuCount}
make install

28
src/app/avadapter.cpp
View file

@ -270,8 +270,8 @@ AvAdapter::stopSharing()
auto callId = lrcInstance_->getCurrentCallId();
if (!callId.isEmpty()) {
lrcInstance_->getCurrentCallModel()->removeMedia(callId,
DRing::Media::Details::MEDIA_TYPE_VIDEO,
DRing::Media::VideoProtocolPrefix::DISPLAY,
libjami::Media::Details::MEDIA_TYPE_VIDEO,
libjami::Media::VideoProtocolPrefix::DISPLAY,
muteCamera_);
}
}
@ -318,9 +318,9 @@ AvAdapter::isSharing() const
auto callModel = lrcInstance_->getCurrentCallModel();
auto call = callModel->getCall(callId);
// TODO enum
return call.hasMediaWithType(DRing::Media::VideoProtocolPrefix::DISPLAY,
DRing::Media::Details::MEDIA_TYPE_VIDEO)
|| call.hasMediaWithType("file:", DRing::Media::Details::MEDIA_TYPE_VIDEO);
return call.hasMediaWithType(libjami::Media::VideoProtocolPrefix::DISPLAY,
libjami::Media::Details::MEDIA_TYPE_VIDEO)
|| call.hasMediaWithType("file:", libjami::Media::Details::MEDIA_TYPE_VIDEO);
} catch (...) {
}
return false;
@ -334,11 +334,11 @@ AvAdapter::isCapturing() const
auto callModel = lrcInstance_->getCurrentCallModel();
auto call = callModel->getCall(callId);
for (const auto& m : call.mediaList) {
if (m[DRing::Media::MediaAttributeKey::SOURCE].startsWith(
DRing::Media::VideoProtocolPrefix::CAMERA)
&& m[DRing::Media::MediaAttributeKey::MEDIA_TYPE]
== DRing::Media::Details::MEDIA_TYPE_VIDEO)
return m[DRing::Media::MediaAttributeKey::MUTED] == FALSE_STR;
if (m[libjami::Media::MediaAttributeKey::SOURCE].startsWith(
libjami::Media::VideoProtocolPrefix::CAMERA)
&& m[libjami::Media::MediaAttributeKey::MEDIA_TYPE]
== libjami::Media::Details::MEDIA_TYPE_VIDEO)
return m[libjami::Media::MediaAttributeKey::MUTED] == FALSE_STR;
}
return false;
} catch (...) {
@ -355,10 +355,10 @@ AvAdapter::hasCamera() const
auto call = callModel->getCall(callId);
// TODO enum
for (const auto& m : call.mediaList) {
if (m[DRing::Media::MediaAttributeKey::SOURCE].startsWith(
DRing::Media::VideoProtocolPrefix::CAMERA)
&& m[DRing::Media::MediaAttributeKey::MEDIA_TYPE]
== DRing::Media::Details::MEDIA_TYPE_VIDEO)
if (m[libjami::Media::MediaAttributeKey::SOURCE].startsWith(
libjami::Media::VideoProtocolPrefix::CAMERA)
&& m[libjami::Media::MediaAttributeKey::MEDIA_TYPE]
== libjami::Media::Details::MEDIA_TYPE_VIDEO)
return true;
}
return false;

32
src/app/calladapter.cpp
View file

@ -703,16 +703,16 @@ CallAdapter::updateCallOverlay(const lrc::api::conversation::Info& convInfo)
QString previewId {};
if (callInfo->status != lrc::api::call::Status::ENDED) {
for (const auto& media : callInfo->mediaList) {
if (media[DRing::Media::MediaAttributeKey::MEDIA_TYPE]
== DRing::Media::Details::MEDIA_TYPE_VIDEO) {
if (media[DRing::Media::MediaAttributeKey::ENABLED] == TRUE_STR
&& media[DRing::Media::MediaAttributeKey::MUTED] == FALSE_STR) {
if (media[libjami::Media::MediaAttributeKey::MEDIA_TYPE]
== libjami::Media::Details::MEDIA_TYPE_VIDEO) {
if (media[libjami::Media::MediaAttributeKey::ENABLED] == TRUE_STR
&& media[libjami::Media::MediaAttributeKey::MUTED] == FALSE_STR) {
if (previewId.isEmpty()) {
previewId = media[DRing::Media::MediaAttributeKey::SOURCE];
previewId = media[libjami::Media::MediaAttributeKey::SOURCE];
}
}
} else if (media[DRing::Media::MediaAttributeKey::LABEL] == "audio_0") {
isAudioMuted |= media[DRing::Media::MediaAttributeKey::MUTED] == TRUE_STR;
} else if (media[libjami::Media::MediaAttributeKey::LABEL] == "audio_0") {
isAudioMuted |= media[libjami::Media::MediaAttributeKey::MUTED] == TRUE_STR;
}
}
}
@ -1075,8 +1075,8 @@ CallAdapter::muteAudioToggle()
const auto callInfo = lrcInstance_->getCurrentCallModel()->getCall(callId);
auto mute = false;
for (const auto& m : callInfo.mediaList)
if (m[DRing::Media::MediaAttributeKey::LABEL] == "audio_0")
mute = m[DRing::Media::MediaAttributeKey::MUTED] == FALSE_STR;
if (m[libjami::Media::MediaAttributeKey::LABEL] == "audio_0")
mute = m[libjami::Media::MediaAttributeKey::MUTED] == FALSE_STR;
callModel->muteMedia(callId, "audio_0", mute);
}
}
@ -1108,11 +1108,11 @@ CallAdapter::muteCameraToggle()
const auto callInfo = lrcInstance_->getCurrentCallModel()->getCall(callId);
auto mute = false;
for (const auto& m : callInfo.mediaList) {
if (m[DRing::Media::MediaAttributeKey::SOURCE].startsWith(
DRing::Media::VideoProtocolPrefix::CAMERA)
&& m[DRing::Media::MediaAttributeKey::MEDIA_TYPE]
== DRing::Media::Details::MEDIA_TYPE_VIDEO) {
mute = m[DRing::Media::MediaAttributeKey::MUTED] == FALSE_STR;
if (m[libjami::Media::MediaAttributeKey::SOURCE].startsWith(
libjami::Media::VideoProtocolPrefix::CAMERA)
&& m[libjami::Media::MediaAttributeKey::MEDIA_TYPE]
== libjami::Media::Details::MEDIA_TYPE_VIDEO) {
mute = m[libjami::Media::MediaAttributeKey::MUTED] == FALSE_STR;
}
}
@ -1121,8 +1121,8 @@ CallAdapter::muteCameraToggle()
// TODO Enum
if (mute)
callModel->removeMedia(callId,
DRing::Media::Details::MEDIA_TYPE_VIDEO,
DRing::Media::VideoProtocolPrefix::CAMERA,
libjami::Media::Details::MEDIA_TYPE_VIDEO,
libjami::Media::VideoProtocolPrefix::CAMERA,
mute);
else
callModel->addMedia(callId,

17
src/libclient/accountmodel.cpp
View file

@ -228,7 +228,7 @@ AccountModel::setAccountConfig(const QString& accountId,
MapStringString details = confProperties.toDetails();
// Set values from Info. No need to include ID and TYPE. SIP accounts may modify the USERNAME
// TODO: move these into the ConfProperties_t struct ?
using namespace DRing::Account;
using namespace libjami::Account;
details[ConfProperties::ENABLED] = accountInfo.enabled ? QString("true") : QString("false");
details[ConfProperties::ALIAS] = accountInfo.profileInfo.alias;
details[ConfProperties::DISPLAYNAME] = accountInfo.profileInfo.alias;
@ -485,7 +485,7 @@ AccountModelPimpl::updateAccountDetails(account::Info& accountInfo)
MapStringString volatileDetails = ConfigurationManager::instance().getVolatileAccountDetails(
accountInfo.id);
QString daemonStatus = volatileDetails[DRing::Account::ConfProperties::Registration::STATUS];
QString daemonStatus = volatileDetails[libjami::Account::ConfProperties::Registration::STATUS];
accountInfo.status = lrc::api::account::to_status(daemonStatus);
}
@ -571,7 +571,7 @@ AccountModelPimpl::slotVolatileAccountDetailsChanged(const QString& accountId,
}
auto& accountInfo = account->second.first;
auto new_usernameIt = details.find(DRing::Account::VolatileProperties::REGISTERED_NAME);
auto new_usernameIt = details.find(libjami::Account::VolatileProperties::REGISTERED_NAME);
if (new_usernameIt == details.end())
return;
accountInfo.registeredName = new_usernameIt.value();
@ -674,7 +674,8 @@ AccountModelPimpl::slotMigrationEnded(const QString& accountId, bool ok)
accountInfo.fromDetails(details);
MapStringString volatileDetails = ConfigurationManager::instance().getVolatileAccountDetails(
accountId);
QString daemonStatus = volatileDetails[DRing::Account::ConfProperties::Registration::STATUS];
QString daemonStatus
= volatileDetails[libjami::Account::ConfProperties::Registration::STATUS];
accountInfo.status = lrc::api::account::to_status(daemonStatus);
}
Q_EMIT linked.migrationEnded(accountId, ok);
@ -779,7 +780,7 @@ AccountModelPimpl::removeFromAccounts(const QString& accountId)
void
account::Info::fromDetails(const MapStringString& details)
{
using namespace DRing::Account;
using namespace libjami::Account;
const MapStringString volatileDetails = ConfigurationManager::instance()
.getVolatileAccountDetails(id);
@ -915,7 +916,7 @@ account::Info::fromDetails(const MapStringString& details)
MapStringString
account::ConfProperties_t::toDetails() const
{
using namespace DRing::Account;
using namespace libjami::Account;
MapStringString details;
// General
details[ConfProperties::MAILBOX] = this->mailbox;
@ -1050,7 +1051,7 @@ AccountModel::createNewAccount(profile::Type type,
MapStringString details = type == profile::Type::SIP
? ConfigurationManager::instance().getAccountTemplate("SIP")
: ConfigurationManager::instance().getAccountTemplate("RING");
using namespace DRing::Account;
using namespace libjami::Account;
details[ConfProperties::TYPE] = type == profile::Type::SIP ? "SIP" : "RING";
details[ConfProperties::DISPLAYNAME] = displayName;
details[ConfProperties::ALIAS] = displayName;
@ -1077,7 +1078,7 @@ AccountModel::connectToAccountManager(const QString& username,
const MapStringString& config)
{
MapStringString details = ConfigurationManager::instance().getAccountTemplate("RING");
using namespace DRing::Account;
using namespace libjami::Account;
details[ConfProperties::TYPE] = "RING";
details[ConfProperties::MANAGER_URI] = serverUri;
details[ConfProperties::MANAGER_USERNAME] = username;

4
src/libclient/api/call.h
View file

@ -144,8 +144,8 @@ struct Info
bool hasMediaWithType(const QString& type, const QString& mediaType) const
{
for (const auto& m : mediaList)
if (m[DRing::Media::MediaAttributeKey::SOURCE].startsWith(type)
&& m[DRing::Media::MediaAttributeKey::MEDIA_TYPE] == mediaType)
if (m[libjami::Media::MediaAttributeKey::SOURCE].startsWith(type)
&& m[libjami::Media::MediaAttributeKey::MEDIA_TYPE] == mediaType)
return true;
return false;
}

10
src/libclient/authority/storagehelper.cpp
View file

@ -1020,7 +1020,7 @@ migrateAccountDb(const QString& accountId,
auto accountLocalPath = getPath() + accountId + "/";
using namespace DRing::Account;
using namespace libjami::Account;
MapStringString accountDetails = ConfigurationManager::instance().getAccountDetails(
accountId.toStdString().c_str());
bool isRingAccount = accountDetails[ConfProperties::TYPE] == "RING";
@ -1032,12 +1032,12 @@ migrateAccountDb(const QString& accountId,
// migrate account's avatar/alias from profiles table to {data_dir}/profile.vcf
QString accountUri;
if (isRingAccount) {
accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME].contains("ring:")
? QString(accountDetails[DRing::Account::ConfProperties::USERNAME])
accountUri = accountDetails[libjami::Account::ConfProperties::USERNAME].contains("ring:")
? QString(accountDetails[libjami::Account::ConfProperties::USERNAME])
.remove(QString("ring:"))
: accountDetails[DRing::Account::ConfProperties::USERNAME];
: accountDetails[libjami::Account::ConfProperties::USERNAME];
} else {
accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME];
accountUri = accountDetails[libjami::Account::ConfProperties::USERNAME];
}
auto accountProfileIds = legacyDb

6
src/libclient/avmodel.cpp
View file

@ -706,9 +706,9 @@ AVModelPimpl::AVModelPimpl(AVModel& linked, const CallbacksHandler& callbacksHan
auto restartRenderers = [&](const QStringList& callList) {
for (const auto& callId : callList) {
MapStringString rendererInfos = VideoManager::instance().getRenderer(callId);
auto shmPath = rendererInfos[DRing::Media::Details::SHM_PATH];
auto width = rendererInfos[DRing::Media::Details::WIDTH].toInt();
auto height = rendererInfos[DRing::Media::Details::HEIGHT].toInt();
auto shmPath = rendererInfos[libjami::Media::Details::SHM_PATH];
auto width = rendererInfos[libjami::Media::Details::WIDTH].toInt();
auto height = rendererInfos[libjami::Media::Details::HEIGHT].toInt();
if (width > 0 && height > 0) {
startedPreview = true;
onDecodingStarted(callId, shmPath, width, height);

54
src/libclient/callbackshandler.cpp
View file

@ -32,7 +32,7 @@
#include "dbus/presencemanager.h"
#include "dbus/videomanager.h"
// DRing
// libjami
#include <datatransfer_interface.h>
#include <QFileInfo>
@ -50,32 +50,32 @@ namespace lrc {
using namespace api;
static inline datatransfer::Status
convertDataTransferEvent(DRing::DataTransferEventCode event)
convertDataTransferEvent(libjami::DataTransferEventCode event)
{
switch (event) {
case DRing::DataTransferEventCode::invalid:
case libjami::DataTransferEventCode::invalid:
return datatransfer::Status::INVALID;
case DRing::DataTransferEventCode::created:
case libjami::DataTransferEventCode::created:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::unsupported:
case libjami::DataTransferEventCode::unsupported:
return datatransfer::Status::unsupported;
case DRing::DataTransferEventCode::wait_peer_acceptance:
case libjami::DataTransferEventCode::wait_peer_acceptance:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::wait_host_acceptance:
case libjami::DataTransferEventCode::wait_host_acceptance:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::ongoing:
case libjami::DataTransferEventCode::ongoing:
return datatransfer::Status::on_progress;
case DRing::DataTransferEventCode::finished:
case libjami::DataTransferEventCode::finished:
return datatransfer::Status::success;
case DRing::DataTransferEventCode::closed_by_host:
case libjami::DataTransferEventCode::closed_by_host:
return datatransfer::Status::stop_by_host;
case DRing::DataTransferEventCode::closed_by_peer:
case libjami::DataTransferEventCode::closed_by_peer:
return datatransfer::Status::stop_by_peer;
case DRing::DataTransferEventCode::invalid_pathname:
case libjami::DataTransferEventCode::invalid_pathname:
return datatransfer::Status::invalid_pathname;
case DRing::DataTransferEventCode::unjoinable_peer:
case libjami::DataTransferEventCode::unjoinable_peer:
return datatransfer::Status::unjoinable_peer;
case DRing::DataTransferEventCode::timeout_expired:
case libjami::DataTransferEventCode::timeout_expired:
return datatransfer::Status::timeout_expired;
}
throw std::runtime_error("BUG: broken convertDataTransferEvent() switch");
@ -602,7 +602,7 @@ CallbacksHandler::slotDataTransferEvent(const QString& accountId,
const QString& fileId,
uint codeStatus)
{
auto event = DRing::DataTransferEventCode(codeStatus);
auto event = libjami::DataTransferEventCode(codeStatus);
api::datatransfer::Info info;
if (conversationId.isEmpty()) {
@ -634,36 +634,36 @@ CallbacksHandler::slotDataTransferEvent(const QString& accountId,
// Is useful for "termination" status like unjoinable_peer.
switch (event) {
case DRing::DataTransferEventCode::created:
case libjami::DataTransferEventCode::created:
Q_EMIT transferStatusCreated(fileId, info);
break;
case DRing::DataTransferEventCode::closed_by_host:
case DRing::DataTransferEventCode::closed_by_peer:
case libjami::DataTransferEventCode::closed_by_host:
case libjami::DataTransferEventCode::closed_by_peer:
Q_EMIT transferStatusCanceled(fileId, info);
break;
case DRing::DataTransferEventCode::wait_peer_acceptance:
case libjami::DataTransferEventCode::wait_peer_acceptance:
Q_EMIT transferStatusAwaitingPeer(fileId, info);
break;
case DRing::DataTransferEventCode::wait_host_acceptance:
case libjami::DataTransferEventCode::wait_host_acceptance:
Q_EMIT transferStatusAwaitingHost(fileId, info);
break;
case DRing::DataTransferEventCode::ongoing:
case libjami::DataTransferEventCode::ongoing:
Q_EMIT transferStatusOngoing(fileId, info);
break;
case DRing::DataTransferEventCode::finished:
case libjami::DataTransferEventCode::finished:
Q_EMIT transferStatusFinished(fileId, info);
break;
case DRing::DataTransferEventCode::invalid_pathname:
case DRing::DataTransferEventCode::unsupported:
case libjami::DataTransferEventCode::invalid_pathname:
case libjami::DataTransferEventCode::unsupported:
Q_EMIT transferStatusError(fileId, info);
break;
case DRing::DataTransferEventCode::timeout_expired:
case libjami::DataTransferEventCode::timeout_expired:
Q_EMIT transferStatusTimeoutExpired(fileId, info);
break;
case DRing::DataTransferEventCode::unjoinable_peer:
case libjami::DataTransferEventCode::unjoinable_peer:
Q_EMIT transferStatusUnjoinable(fileId, info);
break;
case DRing::DataTransferEventCode::invalid:
case libjami::DataTransferEventCode::invalid:
break;
}
}

32
src/libclient/callmodel.cpp
View file

@ -53,7 +53,7 @@
#include <random>
#include <map>
using namespace DRing::Media;
using namespace libjami::Media;
static std::uniform_int_distribution<int> dis {0, std::numeric_limits<int>::max()};
static const std::map<short, QString>
@ -423,11 +423,11 @@ CallModel::replaceDefaultCamera(const QString& callId, const QString& deviceId)
for (auto& media : proposedList) {
if (media[MediaAttributeKey::MEDIA_TYPE] == MediaAttributeValue::VIDEO
&& media[MediaAttributeKey::SOURCE].startsWith(
DRing::Media::VideoProtocolPrefix::CAMERA)) {
libjami::Media::VideoProtocolPrefix::CAMERA)) {
oldPreview = media[MediaAttributeKey::SOURCE];
QString resource = QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::CAMERA)
.arg(DRing::Media::VideoProtocolPrefix::SEPARATOR)
.arg(libjami::Media::VideoProtocolPrefix::CAMERA)
.arg(libjami::Media::VideoProtocolPrefix::SEPARATOR)
.arg(deviceId);
media[MediaAttributeKey::SOURCE] = resource;
newPreview = resource;
@ -457,15 +457,15 @@ CallModel::addMedia(const QString& callId, const QString& source, MediaRequestTy
id++;
}
QString label = QString("video_%1").arg(id);
QString sep = DRing::Media::VideoProtocolPrefix::SEPARATOR;
QString sep = libjami::Media::VideoProtocolPrefix::SEPARATOR;
switch (type) {
case MediaRequestType::FILESHARING: {
// File sharing
resource = !source.isEmpty() ? QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::FILE)
.arg(libjami::Media::VideoProtocolPrefix::FILE)
.arg(sep)
.arg(QUrl(source).toLocalFile())
: DRing::Media::VideoProtocolPrefix::NONE;
: libjami::Media::VideoProtocolPrefix::NONE;
break;
}
case MediaRequestType::SCREENSHARING: {
@ -476,10 +476,10 @@ CallModel::addMedia(const QString& callId, const QString& source, MediaRequestTy
case MediaRequestType::CAMERA: {
// Camera device
resource = not source.isEmpty() ? QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::CAMERA)
.arg(libjami::Media::VideoProtocolPrefix::CAMERA)
.arg(sep)
.arg(source)
: DRing::Media::VideoProtocolPrefix::NONE;
: libjami::Media::VideoProtocolPrefix::NONE;
break;
}
default:
@ -874,9 +874,9 @@ CallModel::getCurrentRenderedDevice(const QString& call_id) const
QString
CallModel::getDisplay(int idx, int x, int y, int w, int h)
{
QString sep = DRing::Media::VideoProtocolPrefix::SEPARATOR;
QString sep = libjami::Media::VideoProtocolPrefix::SEPARATOR;
return QString("%1%2:%3+%4,%5 %6x%7")
.arg(DRing::Media::VideoProtocolPrefix::DISPLAY)
.arg(libjami::Media::VideoProtocolPrefix::DISPLAY)
.arg(sep)
.arg(idx)
.arg(x)
@ -888,9 +888,9 @@ CallModel::getDisplay(int idx, int x, int y, int w, int h)
QString
CallModel::getDisplay(const QString& windowId)
{
QString sep = DRing::Media::VideoProtocolPrefix::SEPARATOR;
QString sep = libjami::Media::VideoProtocolPrefix::SEPARATOR;
return QString("%1%2:+0,0 window-id:%3")
.arg(DRing::Media::VideoProtocolPrefix::DISPLAY)
.arg(libjami::Media::VideoProtocolPrefix::DISPLAY)
.arg(sep)
.arg(windowId);
}
@ -1076,7 +1076,8 @@ CallModel::setCurrentCall(const QString& callId) const
}
for (const auto& cid : Lrc::activeCalls(acc)) {
auto filtered = std::find(filterCalls.begin(), filterCalls.end(), cid) != filterCalls.end();
auto filtered = std::find(filterCalls.begin(), filterCalls.end(), cid)
!= filterCalls.end();
if (cid != callId && !filtered) {
// Only hold calls for a non rendez-vous point
CallManager::instance().hold(acc, cid);
@ -1090,7 +1091,8 @@ CallModel::setCurrentCall(const QString& callId) const
// then we should hold it.
for (const auto& confId : conferences) {
if (callId != confId) {
MapStringString confDetails = CallManager::instance().getConferenceDetails(acc, confId);
MapStringString confDetails = CallManager::instance().getConferenceDetails(acc,
confId);
// Only hold conference if attached
if (confDetails["CALL_STATE"] == "ACTIVE_DETACHED")
continue;

40
src/libclient/codecmodel.cpp
View file

@ -335,17 +335,17 @@ CodecModelPimpl::addCodec(const unsigned int& id, const QVector<unsigned int>& a
Codec codec;
codec.id = id;
codec.enabled = activeCodecs.indexOf(id) != -1;
codec.name = details[DRing::Account::ConfProperties::CodecInfo::NAME];
codec.samplerate = details[DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE];
codec.bitrate = details[DRing::Account::ConfProperties::CodecInfo::BITRATE];
codec.min_bitrate = details[DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE];
codec.max_bitrate = details[DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE];
codec.type = details[DRing::Account::ConfProperties::CodecInfo::TYPE];
codec.quality = details[DRing::Account::ConfProperties::CodecInfo::QUALITY];
codec.min_quality = details[DRing::Account::ConfProperties::CodecInfo::MIN_QUALITY];
codec.max_quality = details[DRing::Account::ConfProperties::CodecInfo::MAX_QUALITY];
codec.name = details[libjami::Account::ConfProperties::CodecInfo::NAME];
codec.samplerate = details[libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE];
codec.bitrate = details[libjami::Account::ConfProperties::CodecInfo::BITRATE];
codec.min_bitrate = details[libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE];
codec.max_bitrate = details[libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE];
codec.type = details[libjami::Account::ConfProperties::CodecInfo::TYPE];
codec.quality = details[libjami::Account::ConfProperties::CodecInfo::QUALITY];
codec.min_quality = details[libjami::Account::ConfProperties::CodecInfo::MIN_QUALITY];
codec.max_quality = details[libjami::Account::ConfProperties::CodecInfo::MAX_QUALITY];
codec.auto_quality_enabled
= details[DRing::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED] == "true";
= details[libjami::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED] == "true";
if (codec.type == "AUDIO") {
std::unique_lock<std::mutex> lock(audioCodecsMtx);
audioCodecs.push_back(codec);
@ -359,16 +359,16 @@ void
CodecModelPimpl::setCodecDetails(const Codec& codec, bool isAudio)
{
MapStringString details;
details[DRing::Account::ConfProperties::CodecInfo::NAME] = codec.name;
details[DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE] = codec.samplerate;
details[DRing::Account::ConfProperties::CodecInfo::BITRATE] = codec.bitrate;
details[DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE] = codec.min_bitrate;
details[DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE] = codec.max_bitrate;
details[DRing::Account::ConfProperties::CodecInfo::TYPE] = isAudio ? "AUDIO" : "VIDEO";
details[DRing::Account::ConfProperties::CodecInfo::QUALITY] = codec.quality;
details[DRing::Account::ConfProperties::CodecInfo::MIN_QUALITY] = codec.min_quality;
details[DRing::Account::ConfProperties::CodecInfo::MAX_QUALITY] = codec.max_quality;
details[DRing::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED]
details[libjami::Account::ConfProperties::CodecInfo::NAME] = codec.name;
details[libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE] = codec.samplerate;
details[libjami::Account::ConfProperties::CodecInfo::BITRATE] = codec.bitrate;
details[libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE] = codec.min_bitrate;
details[libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE] = codec.max_bitrate;
details[libjami::Account::ConfProperties::CodecInfo::TYPE] = isAudio ? "AUDIO" : "VIDEO";
details[libjami::Account::ConfProperties::CodecInfo::QUALITY] = codec.quality;
details[libjami::Account::ConfProperties::CodecInfo::MIN_QUALITY] = codec.min_quality;
details[libjami::Account::ConfProperties::CodecInfo::MAX_QUALITY] = codec.max_quality;
details[libjami::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED]
= codec.auto_quality_enabled ? "true" : "false";
ConfigurationManager::instance().setCodecDetails(linked.owner.id, codec.id, details);
}

6
src/libclient/contactmodel.cpp
View file

@ -726,9 +726,9 @@ ContactModelPimpl::fillWithJamiContacts()
ConfigurationManager::instance().getTrustRequests(linked.owner.id)};
for (const auto& tr_info : pending_tr) {
// Get pending requests.
auto payload = tr_info[DRing::Account::TrustRequest::PAYLOAD].toUtf8();
auto contactUri = tr_info[DRing::Account::TrustRequest::FROM];
auto convId = tr_info[DRing::Account::TrustRequest::CONVERSATIONID];
auto payload = tr_info[libjami::Account::TrustRequest::PAYLOAD].toUtf8();
auto contactUri = tr_info[libjami::Account::TrustRequest::FROM];
auto convId = tr_info[libjami::Account::TrustRequest::CONVERSATIONID];
if (!convId.isEmpty())
continue; // This will be added via getConversationsRequests

30
src/libclient/conversationmodel.cpp
View file

@ -3585,23 +3585,23 @@ ConversationModelPimpl::slotUpdateInteractionStatus(const QString& accountId,
auto conversationIdx = indexOf(convIds[0]);
auto& conversation = conversations[conversationIdx];
auto newStatus = interaction::Status::INVALID;
switch (static_cast<DRing::Account::MessageStates>(status)) {
case DRing::Account::MessageStates::SENDING:
switch (static_cast<libjami::Account::MessageStates>(status)) {
case libjami::Account::MessageStates::SENDING:
newStatus = interaction::Status::SENDING;
break;
case DRing::Account::MessageStates::CANCELLED:
case libjami::Account::MessageStates::CANCELLED:
newStatus = interaction::Status::TRANSFER_CANCELED;
break;
case DRing::Account::MessageStates::SENT:
case libjami::Account::MessageStates::SENT:
newStatus = interaction::Status::SUCCESS;
break;
case DRing::Account::MessageStates::FAILURE:
case libjami::Account::MessageStates::FAILURE:
newStatus = interaction::Status::FAILURE;
break;
case DRing::Account::MessageStates::DISPLAYED:
case libjami::Account::MessageStates::DISPLAYED:
newStatus = interaction::Status::DISPLAYED;
break;
case DRing::Account::MessageStates::UNKNOWN:
case libjami::Account::MessageStates::UNKNOWN:
default:
newStatus = interaction::Status::UNKNOWN;
break;
@ -3609,8 +3609,8 @@ ConversationModelPimpl::slotUpdateInteractionStatus(const QString& accountId,
auto idString = messageId;
// for not swarm conversation messageId in hexdesimal string format. Convert to normal string
// TODO messageId should be received from daemon in string format
if (static_cast<DRing::Account::MessageStates>(status)
== DRing::Account::MessageStates::DISPLAYED) {
if (static_cast<libjami::Account::MessageStates>(status)
== libjami::Account::MessageStates::DISPLAYED) {
std::istringstream ss(messageId.toStdString());
ss >> std::hex;
uint64_t id;
@ -3677,18 +3677,18 @@ ConversationModelPimpl::slotUpdateInteractionStatus(const QString& accountId,
auto& interactions = conversation.interactions;
auto it = interactions->find(messageId);
if (it != interactions->end() && it->second.type == interaction::Type::TEXT) {
if (static_cast<DRing::Account::MessageStates>(status)
== DRing::Account::MessageStates::SENDING) {
if (static_cast<libjami::Account::MessageStates>(status)
== libjami::Account::MessageStates::SENDING) {
it->second.status = interaction::Status::SENDING;
} else if (static_cast<DRing::Account::MessageStates>(status)
== DRing::Account::MessageStates::SENT) {
} else if (static_cast<libjami::Account::MessageStates>(status)
== libjami::Account::MessageStates::SENT) {
it->second.status = interaction::Status::SUCCESS;
}
interactions->emitDataChanged(it, {MessageList::Role::Status});
}
if (static_cast<DRing::Account::MessageStates>(status)
== DRing::Account::MessageStates::DISPLAYED) {
if (static_cast<libjami::Account::MessageStates>(status)
== libjami::Account::MessageStates::DISPLAYED) {
auto previous = conversation.interactions->getRead(peerId);
if (peerId != linked.owner.profileInfo.uri)
conversation.interactions->setRead(peerId, messageId);

38
src/libclient/database.cpp
View file

@ -619,21 +619,22 @@ LegacyDatabase::migrateLocalProfiles()
}
MapStringString account = ConfigurationManager::instance().getAccountDetails(
accountId.toStdString().c_str());
auto accountURI = account[DRing::Account::ConfProperties::USERNAME].contains("ring:")
? account[DRing::Account::ConfProperties::USERNAME]
.toStdString()
.substr(std::string("ring:").size())
: account[DRing::Account::ConfProperties::USERNAME].toStdString();
auto accountURI
= account[libjami::Account::ConfProperties::USERNAME].contains("ring:")
? account[libjami::Account::ConfProperties::USERNAME].toStdString().substr(
std::string("ring:").size())
: account[libjami::Account::ConfProperties::USERNAME].toStdString();
for (const auto& accountId : accountIds) {
MapStringString account = ConfigurationManager::instance().getAccountDetails(
accountId.toStdString().c_str());
auto type = account[DRing::Account::ConfProperties::TYPE] == "SIP" ? "SIP" : "RING";
auto type = account[libjami::Account::ConfProperties::TYPE] == "SIP" ? "SIP"
: "RING";
auto uri = account[DRing::Account::ConfProperties::USERNAME].contains("ring:")
? QString(account[DRing::Account::ConfProperties::USERNAME])
auto uri = account[libjami::Account::ConfProperties::USERNAME].contains("ring:")
? QString(account[libjami::Account::ConfProperties::USERNAME])
.remove(0, QString("ring:").size())
: account[DRing::Account::ConfProperties::USERNAME];
: account[libjami::Account::ConfProperties::USERNAME];
if (select("id", "profiles", "uri=:uri", {{":uri", uri}}).payloads.empty()) {
insertInto("profiles",
{{":uri", "uri"},
@ -748,10 +749,10 @@ LegacyDatabase::migrateTextHistory()
MapStringString details = ConfigurationManager::instance().getAccountDetails(
peersObject["accountId"].toString());
if (!details.contains(DRing::Account::ConfProperties::USERNAME))
if (!details.contains(libjami::Account::ConfProperties::USERNAME))
continue;
auto accountUri = details[DRing::Account::ConfProperties::USERNAME];
auto accountUri = details[libjami::Account::ConfProperties::USERNAME];
auto isARingContact = accountUri.startsWith("ring:");
if (isARingContact) {
accountUri = accountUri.mid(QString("ring:").length());
@ -909,10 +910,10 @@ LegacyDatabase::linkRingProfilesWithAccounts(bool contactsOnly)
}
MapStringString account = ConfigurationManager::instance().getAccountDetails(
accountId.toStdString().c_str());
auto accountURI = account[DRing::Account::ConfProperties::USERNAME].contains("ring:")
? QString(account[DRing::Account::ConfProperties::USERNAME])
auto accountURI = account[libjami::Account::ConfProperties::USERNAME].contains("ring:")
? QString(account[libjami::Account::ConfProperties::USERNAME])
.remove(0, QString("ring:").size())
: account[DRing::Account::ConfProperties::USERNAME];
: account[libjami::Account::ConfProperties::USERNAME];
auto profileIds = select("id", "profiles", "uri=:uri", {{":uri", accountURI}}).payloads;
if (profileIds.empty()) {
continue;
@ -934,7 +935,8 @@ LegacyDatabase::linkRingProfilesWithAccounts(bool contactsOnly)
}
}
if (account[DRing::Account::ConfProperties::TYPE] == DRing::Account::ProtocolNames::RING) {
if (account[libjami::Account::ConfProperties::TYPE]
== libjami::Account::ProtocolNames::RING) {
// update RING contacts
const VectorMapStringString& contacts_vector
= ConfigurationManager::instance().getContacts(accountId.toStdString().c_str());
@ -947,11 +949,11 @@ LegacyDatabase::linkRingProfilesWithAccounts(bool contactsOnly)
const VectorMapStringString& pending_tr
= ConfigurationManager::instance().getTrustRequests(accountId.toStdString().c_str());
for (auto tr_info : pending_tr) {
auto contactURI = tr_info[DRing::Account::TrustRequest::FROM];
auto contactURI = tr_info[libjami::Account::TrustRequest::FROM];
updateProfileAccountForContact(contactURI, accountId);
}
} else if (account[DRing::Account::ConfProperties::TYPE]
== DRing::Account::ProtocolNames::SIP) {
} else if (account[libjami::Account::ConfProperties::TYPE]
== libjami::Account::ProtocolNames::SIP) {
// update SIP contacts
auto conversations = select("id",
"conversations",

30
src/libclient/datatransfermodel.cpp
View file

@ -22,7 +22,7 @@
// Dbus
#include "dbus/configurationmanager.h"
// DRing
// libjami
#include <datatransfer_interface.h>
// Std
@ -39,34 +39,34 @@
namespace lrc {
namespace api {
// DRING to LRC event code conversion
// LIBJAMI to LRC event code conversion
static inline datatransfer::Status
convertDataTransferEvent(DRing::DataTransferEventCode event)
convertDataTransferEvent(libjami::DataTransferEventCode event)
{
switch (event) {
case DRing::DataTransferEventCode::invalid:
case libjami::DataTransferEventCode::invalid:
return datatransfer::Status::INVALID;
case DRing::DataTransferEventCode::created:
case libjami::DataTransferEventCode::created:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::unsupported:
case libjami::DataTransferEventCode::unsupported:
return datatransfer::Status::unsupported;
case DRing::DataTransferEventCode::wait_peer_acceptance:
case libjami::DataTransferEventCode::wait_peer_acceptance:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::wait_host_acceptance:
case libjami::DataTransferEventCode::wait_host_acceptance:
return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::ongoing:
case libjami::DataTransferEventCode::ongoing:
return datatransfer::Status::on_progress;
case DRing::DataTransferEventCode::finished:
case libjami::DataTransferEventCode::finished:
return datatransfer::Status::success;
case DRing::DataTransferEventCode::closed_by_host:
case libjami::DataTransferEventCode::closed_by_host:
return datatransfer::Status::stop_by_host;
case DRing::DataTransferEventCode::closed_by_peer:
case libjami::DataTransferEventCode::closed_by_peer:
return datatransfer::Status::stop_by_peer;
case DRing::DataTransferEventCode::invalid_pathname:
case libjami::DataTransferEventCode::invalid_pathname:
return datatransfer::Status::invalid_pathname;
case DRing::DataTransferEventCode::unjoinable_peer:
case libjami::DataTransferEventCode::unjoinable_peer:
return datatransfer::Status::unjoinable_peer;
case DRing::DataTransferEventCode::timeout_expired:
case libjami::DataTransferEventCode::timeout_expired:
return datatransfer::Status::timeout_expired;
}
throw std::runtime_error("BUG: broken convertDataTransferEvent() switch");

2
src/libclient/devicemodel.cpp
View file

@ -124,7 +124,7 @@ DeviceModelPimpl::DeviceModelPimpl(const DeviceModel& linked,
{
const MapStringString aDetails = ConfigurationManager::instance().getAccountDetails(
linked.owner.id);
currentDeviceId_ = aDetails.value(DRing::Account::ConfProperties::DEVICE_ID);
currentDeviceId_ = aDetails.value(libjami::Account::ConfProperties::DEVICE_ID);
const MapStringString accountDevices = ConfigurationManager::instance().getKnownRingDevices(
linked.owner.id);
auto it = accountDevices.begin();

8
src/libclient/directrenderer.cpp
View file

@ -56,7 +56,7 @@ public:
target.push = std::bind(&Impl::pushCallback, this, _1);
};
DRing::FrameBuffer pullCallback()
libjami::FrameBuffer pullCallback()
{
QMutexLocker lk(&mutex);
if (!frameBufferPtr) {
@ -75,7 +75,7 @@ public:
return std::move(frameBufferPtr);
};
void pushCallback(DRing::FrameBuffer buf)
void pushCallback(libjami::FrameBuffer buf)
{
{
QMutexLocker lk(&mutex);
@ -89,9 +89,9 @@ private:
DirectRenderer* parent_;
public:
DRing::SinkTarget target;
libjami::SinkTarget target;
QMutex mutex;
DRing::FrameBuffer frameBufferPtr;
libjami::FrameBuffer frameBufferPtr;
};
DirectRenderer::DirectRenderer(const QString& id, const QSize& res)

14
src/libclient/lrc.cpp
View file

@ -158,7 +158,7 @@ Lrc::activeCalls(const QString& accountId)
QStringList callLists = CallManager::instance().getCallList(accId);
for (const auto& call : callLists) {
MapStringString callDetails = CallManager::instance().getCallDetails(accId, call);
if (!isFinished(callDetails[QString(DRing::Call::Details::CALL_STATE)]))
if (!isFinished(callDetails[QString(libjami::Call::Details::CALL_STATE)]))
result.push_back(call);
}
}
@ -215,12 +215,12 @@ Lrc::getConferences(const QString& accountId)
bool
isFinished(const QString& callState)
{
if (callState == QLatin1String(DRing::Call::StateEvent::HUNGUP)
|| callState == QLatin1String(DRing::Call::StateEvent::BUSY)
|| callState == QLatin1String(DRing::Call::StateEvent::PEER_BUSY)
|| callState == QLatin1String(DRing::Call::StateEvent::FAILURE)
|| callState == QLatin1String(DRing::Call::StateEvent::INACTIVE)
|| callState == QLatin1String(DRing::Call::StateEvent::OVER)) {
if (callState == QLatin1String(libjami::Call::StateEvent::HUNGUP)
|| callState == QLatin1String(libjami::Call::StateEvent::BUSY)
|| callState == QLatin1String(libjami::Call::StateEvent::PEER_BUSY)
|| callState == QLatin1String(libjami::Call::StateEvent::FAILURE)
|| callState == QLatin1String(libjami::Call::StateEvent::INACTIVE)
|| callState == QLatin1String(libjami::Call::StateEvent::OVER)) {
return true;
}
return false;

355
src/libclient/qtwrapper/callmanager_wrap.h
View file

@ -39,22 +39,22 @@ class CallManagerInterface : public QObject
Q_OBJECT
public:
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> callHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> callHandlers;
CallManagerInterface()
{
using DRing::exportable_callback;
using DRing::CallSignal;
using libjami::exportable_callback;
using libjami::CallSignal;
callHandlers = {
exportable_callback<CallSignal::StateChange>([this](const std::string& accountId,
const std::string& callId,
const std::string& state,
int code) {
LOG_DRING_SIGNAL3("callStateChanged",
QString(callId.c_str()),
QString(state.c_str()),
code);
LOG_LIBJAMI_SIGNAL3("callStateChanged",
QString(callId.c_str()),
QString(state.c_str()),
code);
Q_EMIT callStateChanged(QString(accountId.c_str()),
QString(callId.c_str()),
QString(state.c_str()),
@ -64,34 +64,34 @@ public:
[this](const std::string& callId,
const std::string& event,
const std::vector<std::map<std::string, std::string>>& mediaList) {
LOG_DRING_SIGNAL3("mediaNegotiationStatus",
QString(callId.c_str()),
QString(event.c_str()),
convertVecMap(mediaList));
LOG_LIBJAMI_SIGNAL3("mediaNegotiationStatus",
QString(callId.c_str()),
QString(event.c_str()),
convertVecMap(mediaList));
Q_EMIT mediaNegotiationStatus(QString(callId.c_str()),
QString(event.c_str()),
convertVecMap(mediaList));
}),
exportable_callback<CallSignal::TransferFailed>([this]() {
LOG_DRING_SIGNAL("transferFailed", "");
LOG_LIBJAMI_SIGNAL("transferFailed", "");
Q_EMIT transferFailed();
}),
exportable_callback<CallSignal::TransferSucceeded>([this]() {
LOG_DRING_SIGNAL("transferSucceeded", "");
LOG_LIBJAMI_SIGNAL("transferSucceeded", "");
Q_EMIT transferSucceeded();
}),
exportable_callback<CallSignal::RecordPlaybackStopped>(
[this](const std::string& filepath) {
LOG_DRING_SIGNAL("recordPlaybackStopped", QString(filepath.c_str()));
LOG_LIBJAMI_SIGNAL("recordPlaybackStopped", QString(filepath.c_str()));
Q_EMIT recordPlaybackStopped(QString(filepath.c_str()));
}),
exportable_callback<CallSignal::VoiceMailNotify>(
[this](const std::string& accountId, int newCount, int oldCount, int urgentCount) {
LOG_DRING_SIGNAL4("voiceMailNotify",
QString(accountId.c_str()),
newCount,
oldCount,
urgentCount);
LOG_LIBJAMI_SIGNAL4("voiceMailNotify",
QString(accountId.c_str()),
newCount,
oldCount,
urgentCount);
Q_EMIT voiceMailNotify(QString(accountId.c_str()),
newCount,
oldCount,
@ -102,11 +102,11 @@ public:
const std::string& callId,
const std::string& from,
const std::map<std::string, std::string>& message) {
LOG_DRING_SIGNAL4("incomingMessage",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
convertMap(message));
LOG_LIBJAMI_SIGNAL4("incomingMessage",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
convertMap(message));
Q_EMIT incomingMessage(QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
@ -115,10 +115,10 @@ public:
exportable_callback<CallSignal::IncomingCall>([this](const std::string& accountId,
const std::string& callId,
const std::string& from) {
LOG_DRING_SIGNAL3("incomingCall",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()));
LOG_LIBJAMI_SIGNAL3("incomingCall",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()));
Q_EMIT incomingCall(QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()));
@ -128,11 +128,11 @@ public:
const std::string& callId,
const std::string& from,
const std::vector<std::map<std::string, std::string>>& mediaList) {
LOG_DRING_SIGNAL4("incomingCallWithMedia",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
convertVecMap(mediaList));
LOG_LIBJAMI_SIGNAL4("incomingCallWithMedia",
QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
convertVecMap(mediaList));
Q_EMIT incomingCallWithMedia(QString(accountId.c_str()),
QString(callId.c_str()),
QString(from.c_str()),
@ -142,98 +142,102 @@ public:
[this](const std::string& accountId,
const std::string& callId,
const std::vector<std::map<std::string, std::string>>& mediaList) {
LOG_DRING_SIGNAL3("mediaChangeRequested",
QString(accountId.c_str()),
QString(callId.c_str()),
convertVecMap(mediaList));
LOG_LIBJAMI_SIGNAL3("mediaChangeRequested",
QString(accountId.c_str()),
QString(callId.c_str()),
convertVecMap(mediaList));
Q_EMIT mediaChangeRequested(QString(accountId.c_str()),
QString(callId.c_str()),
convertVecMap(mediaList));
}),
exportable_callback<CallSignal::RecordPlaybackFilepath>(
[this](const std::string& callId, const std::string& filepath) {
LOG_DRING_SIGNAL2("recordPlaybackFilepath",
QString(callId.c_str()),
QString(filepath.c_str()));
LOG_LIBJAMI_SIGNAL2("recordPlaybackFilepath",
QString(callId.c_str()),
QString(filepath.c_str()));
Q_EMIT recordPlaybackFilepath(QString(callId.c_str()),
QString(filepath.c_str()));
}),
exportable_callback<CallSignal::ConferenceCreated>(
[this](const std::string& accountId, const std::string& confId) {
LOG_DRING_SIGNAL2("conferenceCreated",
QString(accountId.c_str()),
QString(confId.c_str()));
LOG_LIBJAMI_SIGNAL2("conferenceCreated",
QString(accountId.c_str()),
QString(confId.c_str()));
Q_EMIT conferenceCreated(QString(accountId.c_str()), QString(confId.c_str()));
}),
exportable_callback<CallSignal::ConferenceChanged>([this](const std::string& accountId,
const std::string& confId,
const std::string& state) {
LOG_DRING_SIGNAL3("conferenceChanged",
QString(accountId.c_str()),
QString(confId.c_str()),
QString(state.c_str()));
LOG_LIBJAMI_SIGNAL3("conferenceChanged",
QString(accountId.c_str()),
QString(confId.c_str()),
QString(state.c_str()));
Q_EMIT conferenceChanged(QString(accountId.c_str()),
QString(confId.c_str()),
QString(state.c_str()));
}),
exportable_callback<CallSignal::UpdatePlaybackScale>([this](const std::string& filepath,
int position,
int size) {
LOG_DRING_SIGNAL3("updatePlaybackScale", QString(filepath.c_str()), position, size);
Q_EMIT updatePlaybackScale(QString(filepath.c_str()), position, size);
}),
exportable_callback<CallSignal::UpdatePlaybackScale>(
[this](const std::string& filepath, int position, int size) {
LOG_LIBJAMI_SIGNAL3("updatePlaybackScale",
QString(filepath.c_str()),
position,
size);
Q_EMIT updatePlaybackScale(QString(filepath.c_str()), position, size);
}),
exportable_callback<CallSignal::ConferenceRemoved>(
[this](const std::string& accountId, const std::string& confId) {
LOG_DRING_SIGNAL2("conferenceRemoved",
QString(accountId.c_str()),
QString(confId.c_str()));
LOG_LIBJAMI_SIGNAL2("conferenceRemoved",
QString(accountId.c_str()),
QString(confId.c_str()));
Q_EMIT conferenceRemoved(QString(accountId.c_str()), QString(confId.c_str()));
}),
exportable_callback<CallSignal::RecordingStateChanged>([this](const std::string& callId,
bool recordingState) {
LOG_DRING_SIGNAL2("recordingStateChanged", QString(callId.c_str()), recordingState);
Q_EMIT recordingStateChanged(QString(callId.c_str()), recordingState);
}),
exportable_callback<CallSignal::RecordingStateChanged>(
[this](const std::string& callId, bool recordingState) {
LOG_LIBJAMI_SIGNAL2("recordingStateChanged",
QString(callId.c_str()),
recordingState);
Q_EMIT recordingStateChanged(QString(callId.c_str()), recordingState);
}),
exportable_callback<CallSignal::RtcpReportReceived>(
[this](const std::string& callId, const std::map<std::string, int>& report) {
LOG_DRING_SIGNAL2("onRtcpReportReceived",
QString(callId.c_str()),
convertStringInt(report));
LOG_LIBJAMI_SIGNAL2("onRtcpReportReceived",
QString(callId.c_str()),
convertStringInt(report));
Q_EMIT onRtcpReportReceived(QString(callId.c_str()), convertStringInt(report));
}),
exportable_callback<CallSignal::OnConferenceInfosUpdated>(
[this](const std::string& confId,
const std::vector<std::map<std::string, std::string>>& infos) {
LOG_DRING_SIGNAL2("onConferenceInfosUpdated",
QString(confId.c_str()),
convertVecMap(infos));
LOG_LIBJAMI_SIGNAL2("onConferenceInfosUpdated",
QString(confId.c_str()),
convertVecMap(infos));
Q_EMIT onConferenceInfosUpdated(QString(confId.c_str()), convertVecMap(infos));
}),
exportable_callback<CallSignal::PeerHold>([this](const std::string& callId, bool state) {
LOG_DRING_SIGNAL2("peerHold", QString(callId.c_str()), state);
LOG_LIBJAMI_SIGNAL2("peerHold", QString(callId.c_str()), state);
Q_EMIT peerHold(QString(callId.c_str()), state);
}),
exportable_callback<CallSignal::AudioMuted>(
[this](const std::string& callId, bool state) {
LOG_DRING_SIGNAL2("audioMuted", QString(callId.c_str()), state);
LOG_LIBJAMI_SIGNAL2("audioMuted", QString(callId.c_str()), state);
Q_EMIT audioMuted(QString(callId.c_str()), state);
}),
exportable_callback<CallSignal::VideoMuted>(
[this](const std::string& callId, bool state) {
LOG_DRING_SIGNAL2("videoMuted", QString(callId.c_str()), state);
LOG_LIBJAMI_SIGNAL2("videoMuted", QString(callId.c_str()), state);
Q_EMIT videoMuted(QString(callId.c_str()), state);
}),
exportable_callback<CallSignal::SmartInfo>(
[this](const std::map<std::string, std::string>& info) {
LOG_DRING_SIGNAL("SmartInfo", "");
LOG_LIBJAMI_SIGNAL("SmartInfo", "");
Q_EMIT SmartInfo(convertMap(info));
}),
exportable_callback<CallSignal::RemoteRecordingChanged>(
[this](const std::string& callId, const std::string& contactId, bool state) {
LOG_DRING_SIGNAL3("remoteRecordingChanged",
QString(callId.c_str()),
QString(contactId.c_str()),
state);
LOG_LIBJAMI_SIGNAL3("remoteRecordingChanged",
QString(callId.c_str()),
QString(contactId.c_str()),
state);
Q_EMIT remoteRecordingChanged(QString(callId.c_str()),
QString(contactId.c_str()),
state);
@ -250,12 +254,12 @@ public:
public Q_SLOTS: // METHODS
bool accept(const QString& accountId, const QString& callId)
{
return DRing::accept(accountId.toStdString(), callId.toStdString());
return libjami::accept(accountId.toStdString(), callId.toStdString());
}
bool addMainParticipant(const QString& accountId, const QString& confId)
{
return DRing::addMainParticipant(accountId.toStdString(), confId.toStdString());
return libjami::addMainParticipant(accountId.toStdString(), confId.toStdString());
}
bool addParticipant(const QString& accountId,
@ -263,113 +267,114 @@ public Q_SLOTS: // METHODS
const QString& account2Id,
const QString& confId)
{
return DRing::addParticipant(accountId.toStdString(),
callId.toStdString(),
account2Id.toStdString(),
confId.toStdString());
return libjami::addParticipant(accountId.toStdString(),
callId.toStdString(),
account2Id.toStdString(),
confId.toStdString());
}
bool attendedTransfer(const QString& accountId,
const QString& transferId,
const QString& targetId)
{
return DRing::attendedTransfer(accountId.toStdString(),
transferId.toStdString(),
targetId.toStdString());
return libjami::attendedTransfer(accountId.toStdString(),
transferId.toStdString(),
targetId.toStdString());
}
void createConfFromParticipantList(const QString& accountId, const QStringList& participants)
{
DRing::createConfFromParticipantList(accountId.toStdString(),
convertStringList(participants));
libjami::createConfFromParticipantList(accountId.toStdString(),
convertStringList(participants));
}
bool detachParticipant(const QString& accountId, const QString& callId)
{
return DRing::detachParticipant(accountId.toStdString(), callId.toStdString());
return libjami::detachParticipant(accountId.toStdString(), callId.toStdString());
}
MapStringString getCallDetails(const QString& accountId, const QString& callId)
{
MapStringString temp = convertMap(
DRing::getCallDetails(accountId.toStdString(), callId.toStdString()));
libjami::getCallDetails(accountId.toStdString(), callId.toStdString()));
return temp;
}
QStringList getCallList(const QString& accountId)
{
QStringList temp = convertStringList(DRing::getCallList(accountId.toStdString()));
QStringList temp = convertStringList(libjami::getCallList(accountId.toStdString()));
return temp;
}
MapStringString getConferenceDetails(const QString& accountId, const QString& callId)
{
MapStringString temp = convertMap(
DRing::getConferenceDetails(accountId.toStdString(), callId.toStdString()));
libjami::getConferenceDetails(accountId.toStdString(), callId.toStdString()));
return temp;
}
VectorMapStringString currentMediaList(const QString& accountId, const QString& callId)
{
VectorMapStringString temp = convertVecMap(
DRing::currentMediaList(accountId.toStdString(), callId.toStdString()));
libjami::currentMediaList(accountId.toStdString(), callId.toStdString()));
return temp;
}
VectorMapStringString getConferenceInfos(const QString& accountId, const QString& confId)
{
VectorMapStringString temp = convertVecMap(
DRing::getConferenceInfos(accountId.toStdString(), confId.toStdString()));
libjami::getConferenceInfos(accountId.toStdString(), confId.toStdString()));
return temp;
}
QString getConferenceId(const QString& accountId, const QString& callId)
{
QString temp(DRing::getConferenceId(accountId.toStdString(), callId.toStdString()).c_str());
QString temp(
libjami::getConferenceId(accountId.toStdString(), callId.toStdString()).c_str());
return temp;
}
QStringList getConferenceList(const QString& accountId)
{
QStringList temp = convertStringList(DRing::getConferenceList(accountId.toStdString()));
QStringList temp = convertStringList(libjami::getConferenceList(accountId.toStdString()));
return temp;
}
bool getIsRecording(const QString& accountId, const QString& callId)
{
return DRing::getIsRecording(accountId.toStdString(), callId.toStdString());
return libjami::getIsRecording(accountId.toStdString(), callId.toStdString());
}
QStringList getParticipantList(const QString& accountId, const QString& confId)
{
QStringList temp = convertStringList(
DRing::getParticipantList(accountId.toStdString(), confId.toStdString()));
libjami::getParticipantList(accountId.toStdString(), confId.toStdString()));
return temp;
}
bool hangUp(const QString& accountId, const QString& callId)
{
return DRing::hangUp(accountId.toStdString(), callId.toStdString());
return libjami::hangUp(accountId.toStdString(), callId.toStdString());
}
bool hangUpConference(const QString& accountId, const QString& confId)
{
return DRing::hangUpConference(accountId.toStdString(), confId.toStdString());
return libjami::hangUpConference(accountId.toStdString(), confId.toStdString());
}
bool hold(const QString& accountId, const QString& callId)
{
return DRing::hold(accountId.toStdString(), callId.toStdString());
return libjami::hold(accountId.toStdString(), callId.toStdString());
}
bool holdConference(const QString& accountId, const QString& confId)
{
return DRing::holdConference(accountId.toStdString(), confId.toStdString());
return libjami::holdConference(accountId.toStdString(), confId.toStdString());
}
bool isConferenceParticipant(const QString& accountId, const QString& callId)
{
return DRing::isConferenceParticipant(accountId.toStdString(), callId.toStdString());
return libjami::isConferenceParticipant(accountId.toStdString(), callId.toStdString());
}
bool joinConference(const QString& accountId,
@ -377,10 +382,10 @@ public Q_SLOTS: // METHODS
const QString& account2Id,
const QString& drag_confId)
{
return DRing::joinConference(accountId.toStdString(),
sel_confId.toStdString(),
account2Id.toStdString(),
drag_confId.toStdString());
return libjami::joinConference(accountId.toStdString(),
sel_confId.toStdString(),
account2Id.toStdString(),
drag_confId.toStdString());
}
bool joinParticipant(const QString& accountId,
@ -388,15 +393,15 @@ public Q_SLOTS: // METHODS
const QString& account2Id,
const QString& drag_callId)
{
return DRing::joinParticipant(accountId.toStdString(),
sel_callId.toStdString(),
account2Id.toStdString(),
drag_callId.toStdString());
return libjami::joinParticipant(accountId.toStdString(),
sel_callId.toStdString(),
account2Id.toStdString(),
drag_callId.toStdString());
}
QString placeCall(const QString& accountId, const QString& to)
{
QString temp(DRing::placeCall(accountId.toStdString(), to.toStdString()).c_str());
QString temp(libjami::placeCall(accountId.toStdString(), to.toStdString()).c_str());
return temp;
}
@ -405,9 +410,9 @@ public Q_SLOTS: // METHODS
const QString& to,
const VectorMapStringString& mediaList)
{
QString temp(DRing::placeCallWithMedia(accountId.toStdString(),
to.toStdString(),
convertVecMap(mediaList))
QString temp(libjami::placeCallWithMedia(accountId.toStdString(),
to.toStdString(),
convertVecMap(mediaList))
.c_str());
return temp;
}
@ -418,43 +423,43 @@ public Q_SLOTS: // METHODS
const QString& callId,
const VectorMapStringString& mediaList)
{
return DRing::requestMediaChange(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
return libjami::requestMediaChange(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
}
bool acceptWithMedia(const QString& accountId,
const QString& callId,
const VectorMapStringString& mediaList)
{
return DRing::acceptWithMedia(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
return libjami::acceptWithMedia(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
}
bool answerMediaChangeRequest(const QString& accountId,
const QString& callId,
const VectorMapStringString& mediaList)
{
return DRing::answerMediaChangeRequest(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
return libjami::answerMediaChangeRequest(accountId.toStdString(),
callId.toStdString(),
convertVecMap(mediaList));
}
// END OF MULTISTREAM FUNCTIONS
void playDTMF(const QString& key)
{
DRing::playDTMF(key.toStdString());
libjami::playDTMF(key.toStdString());
}
void recordPlaybackSeek(double value)
{
DRing::recordPlaybackSeek(value);
libjami::recordPlaybackSeek(value);
}
bool refuse(const QString& accountId, const QString& callId)
{
return DRing::refuse(accountId.toStdString(), callId.toStdString());
return libjami::refuse(accountId.toStdString(), callId.toStdString());
}
void sendTextMessage(const QString& accountId,
@ -462,47 +467,47 @@ public Q_SLOTS: // METHODS
const QMap<QString, QString>& message,
bool isMixed)
{
DRing::sendTextMessage(accountId.toStdString(),
callId.toStdString(),
convertMap(message),
QObject::tr("Me").toStdString(),
isMixed);
libjami::sendTextMessage(accountId.toStdString(),
callId.toStdString(),
convertMap(message),
QObject::tr("Me").toStdString(),
isMixed);
}
bool startRecordedFilePlayback(const QString& filepath)
{
// TODO: Change method name to match API
return DRing::startRecordedFilePlayback(filepath.toStdString());
return libjami::startRecordedFilePlayback(filepath.toStdString());
}
void startTone(int start, int type)
{
DRing::startTone(start, type);
libjami::startTone(start, type);
}
void stopRecordedFilePlayback()
{
DRing::stopRecordedFilePlayback();
libjami::stopRecordedFilePlayback();
}
bool toggleRecording(const QString& accountId, const QString& callId)
{
return DRing::toggleRecording(accountId.toStdString(), callId.toStdString());
return libjami::toggleRecording(accountId.toStdString(), callId.toStdString());
}
bool transfer(const QString& accountId, const QString& callId, const QString& to)
{
return DRing::transfer(accountId.toStdString(), callId.toStdString(), to.toStdString());
return libjami::transfer(accountId.toStdString(), callId.toStdString(), to.toStdString());
}
bool unhold(const QString& accountId, const QString& callId)
{
return DRing::unhold(accountId.toStdString(), callId.toStdString());
return libjami::unhold(accountId.toStdString(), callId.toStdString());
}
bool unholdConference(const QString& accountId, const QString& confId)
{
return DRing::unholdConference(accountId.toStdString(), confId.toStdString());
return libjami::unholdConference(accountId.toStdString(), confId.toStdString());
}
bool muteLocalMedia(const QString& accountId,
@ -510,25 +515,25 @@ public Q_SLOTS: // METHODS
const QString& mediaType,
bool mute)
{
return DRing::muteLocalMedia(accountId.toStdString(),
callId.toStdString(),
mediaType.toStdString(),
mute);
return libjami::muteLocalMedia(accountId.toStdString(),
callId.toStdString(),
mediaType.toStdString(),
mute);
}
void startSmartInfo(int refresh)
{
DRing::startSmartInfo(refresh);
libjami::startSmartInfo(refresh);
}
void stopSmartInfo()
{
DRing::stopSmartInfo();
libjami::stopSmartInfo();
}
void setConferenceLayout(const QString& accountId, const QString& confId, int layout)
{
DRing::setConferenceLayout(accountId.toStdString(), confId.toStdString(), layout);
libjami::setConferenceLayout(accountId.toStdString(), confId.toStdString(), layout);
}
void setActiveStream(const QString& accountId,
@ -538,27 +543,27 @@ public Q_SLOTS: // METHODS
const QString& streamId,
bool state)
{
DRing::setActiveStream(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
streamId.toStdString(),
state);
libjami::setActiveStream(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
streamId.toStdString(),
state);
}
void setActiveParticipant(const QString& accountId, const QString& confId, const QString& callId)
{
DRing::setActiveParticipant(accountId.toStdString(),
confId.toStdString(),
callId.toStdString());
libjami::setActiveParticipant(accountId.toStdString(),
confId.toStdString(),
callId.toStdString());
}
bool switchInput(const QString& accountId, const QString& callId, const QString& resource)
{
#ifdef ENABLE_VIDEO
return DRing::switchInput(accountId.toStdString(),
callId.toStdString(),
resource.toStdString());
return libjami::switchInput(accountId.toStdString(),
callId.toStdString(),
resource.toStdString());
#else
Q_UNUSED(accountId)
Q_UNUSED(callId)
@ -572,10 +577,10 @@ public Q_SLOTS: // METHODS
const QString& peerId,
const bool& state)
{
DRing::setModerator(accountId.toStdString(),
confId.toStdString(),
peerId.toStdString(),
state);
libjami::setModerator(accountId.toStdString(),
confId.toStdString(),
peerId.toStdString(),
state);
}
void muteStream(const QString& accountId,
@ -585,12 +590,12 @@ public Q_SLOTS: // METHODS
const QString& streamId,
bool state)
{
DRing::muteStream(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
streamId.toStdString(),
state);
libjami::muteStream(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
streamId.toStdString(),
state);
}
void hangupParticipant(const QString& accountId,
@ -598,10 +603,10 @@ public Q_SLOTS: // METHODS
const QString& accountUri,
const QString& deviceId)
{
DRing::hangupParticipant(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString());
libjami::hangupParticipant(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString());
}
void raiseHand(const QString& accountId,
@ -610,11 +615,11 @@ public Q_SLOTS: // METHODS
const QString& deviceId,
const bool& state)
{
DRing::raiseHand(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
state);
libjami::raiseHand(accountId.toStdString(),
confId.toStdString(),
accountUri.toStdString(),
deviceId.toStdString(),
state);
}
Q_SIGNALS: // SIGNALS

417
src/libclient/qtwrapper/configurationmanager_wrap.h
View file

File diff suppressed because it is too large Load diff

16
src/libclient/qtwrapper/conversions_wrap.hpp
View file

@ -29,18 +29,18 @@
// Print all call to some signals
#ifdef VERBOSE_IPC
#define LOG_DRING_SIGNAL(name, arg) qDebug() << "\033[22;34m >>>>>> \033[0m" << name << arg;
#define LOG_DRING_SIGNAL2(name, arg, arg2) \
#define LOG_LIBJAMI_SIGNAL(name, arg) qDebug() << "\033[22;34m >>>>>> \033[0m" << name << arg;
#define LOG_LIBJAMI_SIGNAL2(name, arg, arg2) \
qDebug() << "\033[22;34m >>>>>> \033[0m" << name << arg << arg2;
#define LOG_DRING_SIGNAL3(name, arg, arg2, arg3) \
#define LOG_LIBJAMI_SIGNAL3(name, arg, arg2, arg3) \
qDebug() << "\033[22;34m >>>>>> \033[0m" << name << arg << arg2 << arg3;
#define LOG_DRING_SIGNAL4(name, arg, arg2, arg3, arg4) \
#define LOG_LIBJAMI_SIGNAL4(name, arg, arg2, arg3, arg4) \
qDebug() << "\033[22;34m >>>>>> \033[0m" << name << arg << arg2 << arg3 << arg4;
#else
#define LOG_DRING_SIGNAL(name, args) // Nothing
#define LOG_DRING_SIGNAL2(name, arg, arg2)
#define LOG_DRING_SIGNAL3(name, arg, arg2, arg3)
#define LOG_DRING_SIGNAL4(name, arg, arg2, arg3, arg4)
#define LOG_LIBJAMI_SIGNAL(name, args) // Nothing
#define LOG_LIBJAMI_SIGNAL2(name, arg, arg2)
#define LOG_LIBJAMI_SIGNAL3(name, arg, arg2, arg3)
#define LOG_LIBJAMI_SIGNAL4(name, arg, arg2, arg3, arg4)
#endif
inline MapStringString

24
src/libclient/qtwrapper/instancemanager.cpp
View file

@ -32,25 +32,25 @@ InstanceManagerInterface::InstanceManagerInterface(bool muteDring)
using namespace std::placeholders;
using std::bind;
using DRing::exportable_callback;
using DRing::CallSignal;
using DRing::ConfigurationSignal;
using DRing::PresenceSignal;
using DRing::DataTransferSignal;
using DRing::ConversationSignal;
using libjami::exportable_callback;
using libjami::CallSignal;
using libjami::ConfigurationSignal;
using libjami::PresenceSignal;
using libjami::DataTransferSignal;
using libjami::ConversationSignal;
#ifdef ENABLE_VIDEO
using DRing::VideoSignal;
using libjami::VideoSignal;
#endif
#ifndef MUTE_DRING
#ifndef MUTE_LIBJAMI
if (!muteDring) {
ringFlags |= DRing::DRING_FLAG_DEBUG;
ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG;
ringFlags |= libjami::LIBJAMI_FLAG_DEBUG;
ringFlags |= libjami::LIBJAMI_FLAG_CONSOLE_LOG;
}
#endif
DRing::init(static_cast<DRing::InitFlag>(ringFlags));
libjami::init(static_cast<libjami::InitFlag>(ringFlags));
registerSignalHandlers(CallManager::instance().callHandlers);
registerSignalHandlers(ConfigurationManager::instance().confHandlers);
@ -61,7 +61,7 @@ InstanceManagerInterface::InstanceManagerInterface(bool muteDring)
#endif
registerSignalHandlers(ConfigurationManager::instance().conversationsHandlers);
if (!DRing::start())
if (!libjami::start())
printf("Error initializing daemon\n");
else
printf("Daemon is running\n");

2
src/libclient/qtwrapper/instancemanager_wrap.h
View file

@ -53,7 +53,7 @@ public Q_SLOTS: // METHODS
void Unregister(int pid)
{
Q_UNUSED(pid) // When directly linked, the PID is always the current process PID
DRing::fini();
libjami::fini();
}
bool isConnected();

54
src/libclient/qtwrapper/pluginmanager.cpp
View file

@ -21,49 +21,49 @@
bool
PluginManagerInterface::loadPlugin(const QString& path)
{
return DRing::loadPlugin(path.toStdString());
return libjami::loadPlugin(path.toStdString());
}
bool
PluginManagerInterface::unloadPlugin(const QString& path)
{
return DRing::unloadPlugin(path.toStdString());
return libjami::unloadPlugin(path.toStdString());
}
MapStringString
PluginManagerInterface::getPluginDetails(const QString& path)
{
return convertMap(DRing::getPluginDetails(path.toStdString()));
return convertMap(libjami::getPluginDetails(path.toStdString()));
}
QStringList
PluginManagerInterface::getInstalledPlugins()
{
return convertStringList(DRing::getInstalledPlugins());
return convertStringList(libjami::getInstalledPlugins());
}
QStringList
PluginManagerInterface::getLoadedPlugins()
{
return convertStringList(DRing::getLoadedPlugins());
return convertStringList(libjami::getLoadedPlugins());
}
int
PluginManagerInterface::installPlugin(const QString& jplPath, bool force)
{
return DRing::installPlugin(jplPath.toStdString(), force);
return libjami::installPlugin(jplPath.toStdString(), force);
}
int
PluginManagerInterface::uninstallPlugin(const QString& pluginRootPath)
{
return DRing::uninstallPlugin(pluginRootPath.toStdString());
return libjami::uninstallPlugin(pluginRootPath.toStdString());
}
QStringList
PluginManagerInterface::getCallMediaHandlers()
{
return convertStringList(DRing::getCallMediaHandlers());
return convertStringList(libjami::getCallMediaHandlers());
}
void
@ -71,13 +71,13 @@ PluginManagerInterface::toggleCallMediaHandler(const QString& mediaHandlerId,
const QString& callId,
bool toggle)
{
DRing::toggleCallMediaHandler(mediaHandlerId.toStdString(), callId.toStdString(), toggle);
libjami::toggleCallMediaHandler(mediaHandlerId.toStdString(), callId.toStdString(), toggle);
}
QStringList
PluginManagerInterface::getChatHandlers()
{
return convertStringList(DRing::getChatHandlers());
return convertStringList(libjami::getChatHandlers());
}
void
@ -86,54 +86,54 @@ PluginManagerInterface::toggleChatHandler(const QString& chatHandlerId,
const QString& peerId,
bool toggle)
{
DRing::toggleChatHandler(chatHandlerId.toStdString(),
accountId.toStdString(),
peerId.toStdString(),
toggle);
libjami::toggleChatHandler(chatHandlerId.toStdString(),
accountId.toStdString(),
peerId.toStdString(),
toggle);
}
QStringList
PluginManagerInterface::getCallMediaHandlerStatus(const QString& callId)
{
return convertStringList(DRing::getCallMediaHandlerStatus(callId.toStdString()));
return convertStringList(libjami::getCallMediaHandlerStatus(callId.toStdString()));
}
MapStringString
PluginManagerInterface::getCallMediaHandlerDetails(const QString& mediaHandlerId)
{
return convertMap(DRing::getCallMediaHandlerDetails(mediaHandlerId.toStdString()));
return convertMap(libjami::getCallMediaHandlerDetails(mediaHandlerId.toStdString()));
}
QStringList
PluginManagerInterface::getChatHandlerStatus(const QString& accountId, const QString& peerId)
{
return convertStringList(
DRing::getChatHandlerStatus(accountId.toStdString(), peerId.toStdString()));
libjami::getChatHandlerStatus(accountId.toStdString(), peerId.toStdString()));
}
MapStringString
PluginManagerInterface::getChatHandlerDetails(const QString& chatHandlerId)
{
return convertMap(DRing::getChatHandlerDetails(chatHandlerId.toStdString()));
return convertMap(libjami::getChatHandlerDetails(chatHandlerId.toStdString()));
}
void
PluginManagerInterface::setPluginsEnabled(bool enable)
{
DRing::setPluginsEnabled(enable);
libjami::setPluginsEnabled(enable);
}
bool
PluginManagerInterface::getPluginsEnabled()
{
return DRing::getPluginsEnabled();
return libjami::getPluginsEnabled();
}
VectorMapStringString
PluginManagerInterface::getPluginPreferences(const QString& path, const QString& accountId)
{
VectorMapStringString temp;
for (auto x : DRing::getPluginPreferences(path.toStdString(), accountId.toStdString())) {
for (auto x : libjami::getPluginPreferences(path.toStdString(), accountId.toStdString())) {
temp.push_back(convertMap(x));
}
return temp;
@ -145,21 +145,21 @@ PluginManagerInterface::setPluginPreference(const QString& path,
const QString& key,
const QString& value)
{
return DRing::setPluginPreference(path.toStdString(),
accountId.toStdString(),
key.toStdString(),
value.toStdString());
return libjami::setPluginPreference(path.toStdString(),
accountId.toStdString(),
key.toStdString(),
value.toStdString());
}
MapStringString
PluginManagerInterface::getPluginPreferencesValues(const QString& path, const QString& accountId)
{
return convertMap(
DRing::getPluginPreferencesValues(path.toStdString(), accountId.toStdString()));
libjami::getPluginPreferencesValues(path.toStdString(), accountId.toStdString()));
}
bool
PluginManagerInterface::resetPluginPreferencesValues(const QString& path, const QString& accountId)
{
return DRing::resetPluginPreferencesValues(path.toStdString(), accountId.toStdString());
return libjami::resetPluginPreferencesValues(path.toStdString(), accountId.toStdString());
}

16
src/libclient/qtwrapper/presencemanager_wrap.h
View file

@ -38,12 +38,12 @@ class PresenceManagerInterface : public QObject
{
Q_OBJECT
public:
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> presHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> presHandlers;
PresenceManagerInterface()
{
using DRing::exportable_callback;
using DRing::PresenceSignal;
using libjami::exportable_callback;
using libjami::PresenceSignal;
presHandlers
= {exportable_callback<PresenceSignal::NewServerSubscriptionRequest>(
@ -90,13 +90,13 @@ public:
public Q_SLOTS: // METHODS
void answerServerRequest(const QString& uri, bool flag)
{
DRing::answerServerRequest(uri.toStdString(), flag);
libjami::answerServerRequest(uri.toStdString(), flag);
}
VectorMapStringString getSubscriptions(const QString& accountID)
{
VectorMapStringString temp;
for (auto x : DRing::getSubscriptions(accountID.toStdString())) {
for (auto x : libjami::getSubscriptions(accountID.toStdString())) {
temp.push_back(convertMap(x));
}
return temp;
@ -104,17 +104,17 @@ public Q_SLOTS: // METHODS
void publish(const QString& accountID, bool status, const QString& note)
{
DRing::publish(accountID.toStdString(), status, note.toStdString());
libjami::publish(accountID.toStdString(), status, note.toStdString());
}
void setSubscriptions(const QString& accountID, const QStringList& uriList)
{
DRing::setSubscriptions(accountID.toStdString(), convertStringList(uriList));
libjami::setSubscriptions(accountID.toStdString(), convertStringList(uriList));
}
void subscribeBuddy(const QString& accountID, const QString& uri, bool flag)
{
DRing::subscribeBuddy(accountID.toStdString(), uri.toStdString(), flag);
libjami::subscribeBuddy(accountID.toStdString(), uri.toStdString(), flag);
}
Q_SIGNALS: // SIGNALS

13
src/libclient/qtwrapper/videomanager_wrap.cpp
View file

@ -21,8 +21,8 @@
VideoManagerInterface::VideoManagerInterface()
{
#ifdef ENABLE_VIDEO
using DRing::exportable_callback;
using DRing::VideoSignal;
using libjami::exportable_callback;
using libjami::VideoSignal;
videoHandlers
= {exportable_callback<VideoSignal::DeviceEvent>([this]() { Q_EMIT deviceEvent(); }),
exportable_callback<VideoSignal::DecodingStarted>([this](const std::string& id,
@ -36,11 +36,10 @@ VideoManagerInterface::VideoManagerInterface()
height,
isMixer);
}),
exportable_callback<VideoSignal::DecodingStopped>([this](const std::string& id,
const std::string& shmPath,
bool isMixer) {
Q_EMIT decodingStopped(QString(id.c_str()), QString(shmPath.c_str()), isMixer);
})};
exportable_callback<VideoSignal::DecodingStopped>(
[this](const std::string& id, const std::string& shmPath, bool isMixer) {
Q_EMIT decodingStopped(QString(id.c_str()), QString(shmPath.c_str()), isMixer);
})};
#endif
}

61
src/libclient/qtwrapper/videomanager_wrap.h
View file

@ -50,14 +50,14 @@ public:
~VideoManagerInterface();
#ifdef ENABLE_VIDEO
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> videoHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> videoHandlers;
#endif
public Q_SLOTS: // METHODS
void applySettings(const QString& name, MapStringString settings)
{
#ifdef ENABLE_VIDEO
DRing::applySettings(name.toStdString(), convertMap(settings));
libjami::applySettings(name.toStdString(), convertMap(settings));
#else
Q_UNUSED(name)
Q_UNUSED(settings)
@ -69,7 +69,7 @@ public Q_SLOTS: // METHODS
MapStringMapStringVectorString ret;
#ifdef ENABLE_VIDEO
std::map<std::string, std::map<std::string, std::vector<std::string>>> temp;
temp = DRing::getCapabilities(name.toStdString());
temp = libjami::getCapabilities(name.toStdString());
for (auto& x : temp) {
QMap<QString, VectorString> ytemp;
@ -87,7 +87,7 @@ public Q_SLOTS: // METHODS
QString getDefaultDevice()
{
#ifdef ENABLE_VIDEO
return QString::fromStdString(DRing::getDefaultDevice().c_str());
return QString::fromStdString(libjami::getDefaultDevice().c_str());
#else
return QString();
#endif
@ -96,7 +96,7 @@ public Q_SLOTS: // METHODS
QStringList getDeviceList()
{
#ifdef ENABLE_VIDEO
QStringList temp = convertStringList(DRing::getDeviceList());
QStringList temp = convertStringList(libjami::getDeviceList());
#else
QStringList temp;
#endif
@ -106,7 +106,7 @@ public Q_SLOTS: // METHODS
MapStringString getSettings(const QString& device)
{
#ifdef ENABLE_VIDEO
MapStringString temp = convertMap(DRing::getSettings(device.toStdString()));
MapStringString temp = convertMap(libjami::getSettings(device.toStdString()));
#else
Q_UNUSED(device)
MapStringString temp;
@ -117,7 +117,7 @@ public Q_SLOTS: // METHODS
void setDefaultDevice(const QString& name)
{
#ifdef ENABLE_VIDEO
DRing::setDefaultDevice(name.toStdString());
libjami::setDefaultDevice(name.toStdString());
#else
Q_UNUSED(name)
#endif
@ -126,25 +126,31 @@ public Q_SLOTS: // METHODS
QString openVideoInput(const QString& resource)
{
#ifdef ENABLE_VIDEO
return DRing::openVideoInput(resource.toStdString()).c_str();
return libjami::openVideoInput(resource.toStdString()).c_str();
#endif
}
void closeVideoInput(const QString& resource)
{
#ifdef ENABLE_VIDEO
DRing::closeVideoInput(resource.toStdString());
libjami::closeVideoInput(resource.toStdString());
#endif
}
void startAudioDevice() { DRing::startAudioDevice(); }
void startAudioDevice()
{
libjami::startAudioDevice();
}
void stopAudioDevice() { DRing::stopAudioDevice(); }
void stopAudioDevice()
{
libjami::stopAudioDevice();
}
bool registerSinkTarget(const QString& sinkID, const DRing::SinkTarget& target)
bool registerSinkTarget(const QString& sinkID, const libjami::SinkTarget& target)
{
#ifdef ENABLE_VIDEO
return DRing::registerSinkTarget(sinkID.toStdString(), target);
return libjami::registerSinkTarget(sinkID.toStdString(), target);
#else
Q_UNUSED(sinkID)
Q_UNUSED(target)
@ -152,25 +158,40 @@ public Q_SLOTS: // METHODS
#endif
}
bool getDecodingAccelerated() { return DRing::getDecodingAccelerated(); }
bool getDecodingAccelerated()
{
return libjami::getDecodingAccelerated();
}
void setDecodingAccelerated(bool state) { DRing::setDecodingAccelerated(state); }
void setDecodingAccelerated(bool state)
{
libjami::setDecodingAccelerated(state);
}
bool getEncodingAccelerated() { return DRing::getEncodingAccelerated(); }
bool getEncodingAccelerated()
{
return libjami::getEncodingAccelerated();
}
void setEncodingAccelerated(bool state) { DRing::setEncodingAccelerated(state); }
void setEncodingAccelerated(bool state)
{
libjami::setEncodingAccelerated(state);
}
void stopLocalRecorder(const QString& path) { DRing::stopLocalRecorder(path.toStdString()); }
void stopLocalRecorder(const QString& path)
{
libjami::stopLocalRecorder(path.toStdString());
}
QString startLocalMediaRecorder(const QString& videoInputId, const QString& path)
{
return QString::fromStdString(
DRing::startLocalMediaRecorder(videoInputId.toStdString(), path.toStdString()));
libjami::startLocalMediaRecorder(videoInputId.toStdString(), path.toStdString()));
}
MapStringString getRenderer(const QString& id)
{
return convertMap(DRing::getRenderer(id.toStdString()));
return convertMap(libjami::getRenderer(id.toStdString()));
}
Q_SIGNALS: // SIGNALS

2
src/libclient/typedefs.h
View file

@ -44,7 +44,7 @@ typedef uint64_t DataTransferId;
constexpr static const char* TRUE_STR = "true";
constexpr static const char* FALSE_STR = "false";
// Adapted from libring DRing::DataTransferInfo
// Adapted from libring libjami::DataTransferInfo
struct DataTransferInfo
{
QString accountId;