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 cd build
echo "Building lrc in "$PWD echo "Building lrc in "$PWD
cmake .. -DCMAKE_INSTALL_PREFIX=$installDir/lrc \ cmake .. -DCMAKE_INSTALL_PREFIX=$installDir/lrc \
-DRING_INCLUDE_DIR=$daemonDir/src/jami \ -LIBJAMI_INCLUDE_DIR=$daemonDir/src/jami \
-DRING_XML_INTERFACES_DIR=$daemonDir/bin/dbus -LIBJAMI_XML_INTERFACES_DIR=$daemonDir/bin/dbus
make -j${cpuCount} make -j${cpuCount}
make install make install

28
src/app/avadapter.cpp
View file

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

32
src/app/calladapter.cpp
View file

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

17
src/libclient/accountmodel.cpp
View file

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

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

@ -1020,7 +1020,7 @@ migrateAccountDb(const QString& accountId,
auto accountLocalPath = getPath() + accountId + "/"; auto accountLocalPath = getPath() + accountId + "/";
using namespace DRing::Account; using namespace libjami::Account;
MapStringString accountDetails = ConfigurationManager::instance().getAccountDetails( MapStringString accountDetails = ConfigurationManager::instance().getAccountDetails(
accountId.toStdString().c_str()); accountId.toStdString().c_str());
bool isRingAccount = accountDetails[ConfProperties::TYPE] == "RING"; 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 // migrate account's avatar/alias from profiles table to {data_dir}/profile.vcf
QString accountUri; QString accountUri;
if (isRingAccount) { if (isRingAccount) {
accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME].contains("ring:") accountUri = accountDetails[libjami::Account::ConfProperties::USERNAME].contains("ring:")
? QString(accountDetails[DRing::Account::ConfProperties::USERNAME]) ? QString(accountDetails[libjami::Account::ConfProperties::USERNAME])
.remove(QString("ring:")) .remove(QString("ring:"))
: accountDetails[DRing::Account::ConfProperties::USERNAME]; : accountDetails[libjami::Account::ConfProperties::USERNAME];
} else { } else {
accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME]; accountUri = accountDetails[libjami::Account::ConfProperties::USERNAME];
} }
auto accountProfileIds = legacyDb 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) { auto restartRenderers = [&](const QStringList& callList) {
for (const auto& callId : callList) { for (const auto& callId : callList) {
MapStringString rendererInfos = VideoManager::instance().getRenderer(callId); MapStringString rendererInfos = VideoManager::instance().getRenderer(callId);
auto shmPath = rendererInfos[DRing::Media::Details::SHM_PATH]; auto shmPath = rendererInfos[libjami::Media::Details::SHM_PATH];
auto width = rendererInfos[DRing::Media::Details::WIDTH].toInt(); auto width = rendererInfos[libjami::Media::Details::WIDTH].toInt();
auto height = rendererInfos[DRing::Media::Details::HEIGHT].toInt(); auto height = rendererInfos[libjami::Media::Details::HEIGHT].toInt();
if (width > 0 && height > 0) { if (width > 0 && height > 0) {
startedPreview = true; startedPreview = true;
onDecodingStarted(callId, shmPath, width, height); onDecodingStarted(callId, shmPath, width, height);

54
src/libclient/callbackshandler.cpp
View file

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

32
src/libclient/callmodel.cpp
View file

@ -53,7 +53,7 @@
#include <random> #include <random>
#include <map> #include <map>
using namespace DRing::Media; using namespace libjami::Media;
static std::uniform_int_distribution<int> dis {0, std::numeric_limits<int>::max()}; static std::uniform_int_distribution<int> dis {0, std::numeric_limits<int>::max()};
static const std::map<short, QString> static const std::map<short, QString>
@ -423,11 +423,11 @@ CallModel::replaceDefaultCamera(const QString& callId, const QString& deviceId)
for (auto& media : proposedList) { for (auto& media : proposedList) {
if (media[MediaAttributeKey::MEDIA_TYPE] == MediaAttributeValue::VIDEO if (media[MediaAttributeKey::MEDIA_TYPE] == MediaAttributeValue::VIDEO
&& media[MediaAttributeKey::SOURCE].startsWith( && media[MediaAttributeKey::SOURCE].startsWith(
DRing::Media::VideoProtocolPrefix::CAMERA)) { libjami::Media::VideoProtocolPrefix::CAMERA)) {
oldPreview = media[MediaAttributeKey::SOURCE]; oldPreview = media[MediaAttributeKey::SOURCE];
QString resource = QString("%1%2%3") QString resource = QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::CAMERA) .arg(libjami::Media::VideoProtocolPrefix::CAMERA)
.arg(DRing::Media::VideoProtocolPrefix::SEPARATOR) .arg(libjami::Media::VideoProtocolPrefix::SEPARATOR)
.arg(deviceId); .arg(deviceId);
media[MediaAttributeKey::SOURCE] = resource; media[MediaAttributeKey::SOURCE] = resource;
newPreview = resource; newPreview = resource;
@ -457,15 +457,15 @@ CallModel::addMedia(const QString& callId, const QString& source, MediaRequestTy
id++; id++;
} }
QString label = QString("video_%1").arg(id); QString label = QString("video_%1").arg(id);
QString sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; QString sep = libjami::Media::VideoProtocolPrefix::SEPARATOR;
switch (type) { switch (type) {
case MediaRequestType::FILESHARING: { case MediaRequestType::FILESHARING: {
// File sharing // File sharing
resource = !source.isEmpty() ? QString("%1%2%3") resource = !source.isEmpty() ? QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::FILE) .arg(libjami::Media::VideoProtocolPrefix::FILE)
.arg(sep) .arg(sep)
.arg(QUrl(source).toLocalFile()) .arg(QUrl(source).toLocalFile())
: DRing::Media::VideoProtocolPrefix::NONE; : libjami::Media::VideoProtocolPrefix::NONE;
break; break;
} }
case MediaRequestType::SCREENSHARING: { case MediaRequestType::SCREENSHARING: {
@ -476,10 +476,10 @@ CallModel::addMedia(const QString& callId, const QString& source, MediaRequestTy
case MediaRequestType::CAMERA: { case MediaRequestType::CAMERA: {
// Camera device // Camera device
resource = not source.isEmpty() ? QString("%1%2%3") resource = not source.isEmpty() ? QString("%1%2%3")
.arg(DRing::Media::VideoProtocolPrefix::CAMERA) .arg(libjami::Media::VideoProtocolPrefix::CAMERA)
.arg(sep) .arg(sep)
.arg(source) .arg(source)
: DRing::Media::VideoProtocolPrefix::NONE; : libjami::Media::VideoProtocolPrefix::NONE;
break; break;
} }
default: default:
@ -874,9 +874,9 @@ CallModel::getCurrentRenderedDevice(const QString& call_id) const
QString QString
CallModel::getDisplay(int idx, int x, int y, int w, int h) 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") return QString("%1%2:%3+%4,%5 %6x%7")
.arg(DRing::Media::VideoProtocolPrefix::DISPLAY) .arg(libjami::Media::VideoProtocolPrefix::DISPLAY)
.arg(sep) .arg(sep)
.arg(idx) .arg(idx)
.arg(x) .arg(x)
@ -888,9 +888,9 @@ CallModel::getDisplay(int idx, int x, int y, int w, int h)
QString QString
CallModel::getDisplay(const QString& windowId) 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") return QString("%1%2:+0,0 window-id:%3")
.arg(DRing::Media::VideoProtocolPrefix::DISPLAY) .arg(libjami::Media::VideoProtocolPrefix::DISPLAY)
.arg(sep) .arg(sep)
.arg(windowId); .arg(windowId);
} }
@ -1076,7 +1076,8 @@ CallModel::setCurrentCall(const QString& callId) const
} }
for (const auto& cid : Lrc::activeCalls(acc)) { 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) { if (cid != callId && !filtered) {
// Only hold calls for a non rendez-vous point // Only hold calls for a non rendez-vous point
CallManager::instance().hold(acc, cid); CallManager::instance().hold(acc, cid);
@ -1090,7 +1091,8 @@ CallModel::setCurrentCall(const QString& callId) const
// then we should hold it. // then we should hold it.
for (const auto& confId : conferences) { for (const auto& confId : conferences) {
if (callId != confId) { if (callId != confId) {
MapStringString confDetails = CallManager::instance().getConferenceDetails(acc, confId); MapStringString confDetails = CallManager::instance().getConferenceDetails(acc,
confId);
// Only hold conference if attached // Only hold conference if attached
if (confDetails["CALL_STATE"] == "ACTIVE_DETACHED") if (confDetails["CALL_STATE"] == "ACTIVE_DETACHED")
continue; 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 codec;
codec.id = id; codec.id = id;
codec.enabled = activeCodecs.indexOf(id) != -1; codec.enabled = activeCodecs.indexOf(id) != -1;
codec.name = details[DRing::Account::ConfProperties::CodecInfo::NAME]; codec.name = details[libjami::Account::ConfProperties::CodecInfo::NAME];
codec.samplerate = details[DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE]; codec.samplerate = details[libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE];
codec.bitrate = details[DRing::Account::ConfProperties::CodecInfo::BITRATE]; codec.bitrate = details[libjami::Account::ConfProperties::CodecInfo::BITRATE];
codec.min_bitrate = details[DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE]; codec.min_bitrate = details[libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE];
codec.max_bitrate = details[DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE]; codec.max_bitrate = details[libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE];
codec.type = details[DRing::Account::ConfProperties::CodecInfo::TYPE]; codec.type = details[libjami::Account::ConfProperties::CodecInfo::TYPE];
codec.quality = details[DRing::Account::ConfProperties::CodecInfo::QUALITY]; codec.quality = details[libjami::Account::ConfProperties::CodecInfo::QUALITY];
codec.min_quality = details[DRing::Account::ConfProperties::CodecInfo::MIN_QUALITY]; codec.min_quality = details[libjami::Account::ConfProperties::CodecInfo::MIN_QUALITY];
codec.max_quality = details[DRing::Account::ConfProperties::CodecInfo::MAX_QUALITY]; codec.max_quality = details[libjami::Account::ConfProperties::CodecInfo::MAX_QUALITY];
codec.auto_quality_enabled 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") { if (codec.type == "AUDIO") {
std::unique_lock<std::mutex> lock(audioCodecsMtx); std::unique_lock<std::mutex> lock(audioCodecsMtx);
audioCodecs.push_back(codec); audioCodecs.push_back(codec);
@ -359,16 +359,16 @@ void
CodecModelPimpl::setCodecDetails(const Codec& codec, bool isAudio) CodecModelPimpl::setCodecDetails(const Codec& codec, bool isAudio)
{ {
MapStringString details; MapStringString details;
details[DRing::Account::ConfProperties::CodecInfo::NAME] = codec.name; details[libjami::Account::ConfProperties::CodecInfo::NAME] = codec.name;
details[DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE] = codec.samplerate; details[libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE] = codec.samplerate;
details[DRing::Account::ConfProperties::CodecInfo::BITRATE] = codec.bitrate; details[libjami::Account::ConfProperties::CodecInfo::BITRATE] = codec.bitrate;
details[DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE] = codec.min_bitrate; details[libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE] = codec.min_bitrate;
details[DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE] = codec.max_bitrate; details[libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE] = codec.max_bitrate;
details[DRing::Account::ConfProperties::CodecInfo::TYPE] = isAudio ? "AUDIO" : "VIDEO"; details[libjami::Account::ConfProperties::CodecInfo::TYPE] = isAudio ? "AUDIO" : "VIDEO";
details[DRing::Account::ConfProperties::CodecInfo::QUALITY] = codec.quality; details[libjami::Account::ConfProperties::CodecInfo::QUALITY] = codec.quality;
details[DRing::Account::ConfProperties::CodecInfo::MIN_QUALITY] = codec.min_quality; details[libjami::Account::ConfProperties::CodecInfo::MIN_QUALITY] = codec.min_quality;
details[DRing::Account::ConfProperties::CodecInfo::MAX_QUALITY] = codec.max_quality; details[libjami::Account::ConfProperties::CodecInfo::MAX_QUALITY] = codec.max_quality;
details[DRing::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED] details[libjami::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED]
= codec.auto_quality_enabled ? "true" : "false"; = codec.auto_quality_enabled ? "true" : "false";
ConfigurationManager::instance().setCodecDetails(linked.owner.id, codec.id, details); 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)}; ConfigurationManager::instance().getTrustRequests(linked.owner.id)};
for (const auto& tr_info : pending_tr) { for (const auto& tr_info : pending_tr) {
// Get pending requests. // Get pending requests.
auto payload = tr_info[DRing::Account::TrustRequest::PAYLOAD].toUtf8(); auto payload = tr_info[libjami::Account::TrustRequest::PAYLOAD].toUtf8();
auto contactUri = tr_info[DRing::Account::TrustRequest::FROM]; auto contactUri = tr_info[libjami::Account::TrustRequest::FROM];
auto convId = tr_info[DRing::Account::TrustRequest::CONVERSATIONID]; auto convId = tr_info[libjami::Account::TrustRequest::CONVERSATIONID];
if (!convId.isEmpty()) if (!convId.isEmpty())
continue; // This will be added via getConversationsRequests 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 conversationIdx = indexOf(convIds[0]);
auto& conversation = conversations[conversationIdx]; auto& conversation = conversations[conversationIdx];
auto newStatus = interaction::Status::INVALID; auto newStatus = interaction::Status::INVALID;
switch (static_cast<DRing::Account::MessageStates>(status)) { switch (static_cast<libjami::Account::MessageStates>(status)) {
case DRing::Account::MessageStates::SENDING: case libjami::Account::MessageStates::SENDING:
newStatus = interaction::Status::SENDING; newStatus = interaction::Status::SENDING;
break; break;
case DRing::Account::MessageStates::CANCELLED: case libjami::Account::MessageStates::CANCELLED:
newStatus = interaction::Status::TRANSFER_CANCELED; newStatus = interaction::Status::TRANSFER_CANCELED;
break; break;
case DRing::Account::MessageStates::SENT: case libjami::Account::MessageStates::SENT:
newStatus = interaction::Status::SUCCESS; newStatus = interaction::Status::SUCCESS;
break; break;
case DRing::Account::MessageStates::FAILURE: case libjami::Account::MessageStates::FAILURE:
newStatus = interaction::Status::FAILURE; newStatus = interaction::Status::FAILURE;
break; break;
case DRing::Account::MessageStates::DISPLAYED: case libjami::Account::MessageStates::DISPLAYED:
newStatus = interaction::Status::DISPLAYED; newStatus = interaction::Status::DISPLAYED;
break; break;
case DRing::Account::MessageStates::UNKNOWN: case libjami::Account::MessageStates::UNKNOWN:
default: default:
newStatus = interaction::Status::UNKNOWN; newStatus = interaction::Status::UNKNOWN;
break; break;
@ -3609,8 +3609,8 @@ ConversationModelPimpl::slotUpdateInteractionStatus(const QString& accountId,
auto idString = messageId; auto idString = messageId;
// for not swarm conversation messageId in hexdesimal string format. Convert to normal string // for not swarm conversation messageId in hexdesimal string format. Convert to normal string
// TODO messageId should be received from daemon in string format // TODO messageId should be received from daemon in string format
if (static_cast<DRing::Account::MessageStates>(status) if (static_cast<libjami::Account::MessageStates>(status)
== DRing::Account::MessageStates::DISPLAYED) { == libjami::Account::MessageStates::DISPLAYED) {
std::istringstream ss(messageId.toStdString()); std::istringstream ss(messageId.toStdString());
ss >> std::hex; ss >> std::hex;
uint64_t id; uint64_t id;
@ -3677,18 +3677,18 @@ ConversationModelPimpl::slotUpdateInteractionStatus(const QString& accountId,
auto& interactions = conversation.interactions; auto& interactions = conversation.interactions;
auto it = interactions->find(messageId); auto it = interactions->find(messageId);
if (it != interactions->end() && it->second.type == interaction::Type::TEXT) { if (it != interactions->end() && it->second.type == interaction::Type::TEXT) {
if (static_cast<DRing::Account::MessageStates>(status) if (static_cast<libjami::Account::MessageStates>(status)
== DRing::Account::MessageStates::SENDING) { == libjami::Account::MessageStates::SENDING) {
it->second.status = interaction::Status::SENDING; it->second.status = interaction::Status::SENDING;
} else if (static_cast<DRing::Account::MessageStates>(status) } else if (static_cast<libjami::Account::MessageStates>(status)
== DRing::Account::MessageStates::SENT) { == libjami::Account::MessageStates::SENT) {
it->second.status = interaction::Status::SUCCESS; it->second.status = interaction::Status::SUCCESS;
} }
interactions->emitDataChanged(it, {MessageList::Role::Status}); interactions->emitDataChanged(it, {MessageList::Role::Status});
} }
if (static_cast<DRing::Account::MessageStates>(status) if (static_cast<libjami::Account::MessageStates>(status)
== DRing::Account::MessageStates::DISPLAYED) { == libjami::Account::MessageStates::DISPLAYED) {
auto previous = conversation.interactions->getRead(peerId); auto previous = conversation.interactions->getRead(peerId);
if (peerId != linked.owner.profileInfo.uri) if (peerId != linked.owner.profileInfo.uri)
conversation.interactions->setRead(peerId, messageId); conversation.interactions->setRead(peerId, messageId);

38
src/libclient/database.cpp
View file

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

30
src/libclient/datatransfermodel.cpp
View file

@ -22,7 +22,7 @@
// Dbus // Dbus
#include "dbus/configurationmanager.h" #include "dbus/configurationmanager.h"
// DRing // libjami
#include <datatransfer_interface.h> #include <datatransfer_interface.h>
// Std // Std
@ -39,34 +39,34 @@
namespace lrc { namespace lrc {
namespace api { namespace api {
// DRING to LRC event code conversion // LIBJAMI to LRC event code conversion
static inline datatransfer::Status static inline datatransfer::Status
convertDataTransferEvent(DRing::DataTransferEventCode event) convertDataTransferEvent(libjami::DataTransferEventCode event)
{ {
switch (event) { switch (event) {
case DRing::DataTransferEventCode::invalid: case libjami::DataTransferEventCode::invalid:
return datatransfer::Status::INVALID; return datatransfer::Status::INVALID;
case DRing::DataTransferEventCode::created: case libjami::DataTransferEventCode::created:
return datatransfer::Status::on_connection; return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::unsupported: case libjami::DataTransferEventCode::unsupported:
return datatransfer::Status::unsupported; return datatransfer::Status::unsupported;
case DRing::DataTransferEventCode::wait_peer_acceptance: case libjami::DataTransferEventCode::wait_peer_acceptance:
return datatransfer::Status::on_connection; return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::wait_host_acceptance: case libjami::DataTransferEventCode::wait_host_acceptance:
return datatransfer::Status::on_connection; return datatransfer::Status::on_connection;
case DRing::DataTransferEventCode::ongoing: case libjami::DataTransferEventCode::ongoing:
return datatransfer::Status::on_progress; return datatransfer::Status::on_progress;
case DRing::DataTransferEventCode::finished: case libjami::DataTransferEventCode::finished:
return datatransfer::Status::success; return datatransfer::Status::success;
case DRing::DataTransferEventCode::closed_by_host: case libjami::DataTransferEventCode::closed_by_host:
return datatransfer::Status::stop_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; return datatransfer::Status::stop_by_peer;
case DRing::DataTransferEventCode::invalid_pathname: case libjami::DataTransferEventCode::invalid_pathname:
return datatransfer::Status::invalid_pathname; return datatransfer::Status::invalid_pathname;
case DRing::DataTransferEventCode::unjoinable_peer: case libjami::DataTransferEventCode::unjoinable_peer:
return datatransfer::Status::unjoinable_peer; return datatransfer::Status::unjoinable_peer;
case DRing::DataTransferEventCode::timeout_expired: case libjami::DataTransferEventCode::timeout_expired:
return datatransfer::Status::timeout_expired; return datatransfer::Status::timeout_expired;
} }
throw std::runtime_error("BUG: broken convertDataTransferEvent() switch"); 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( const MapStringString aDetails = ConfigurationManager::instance().getAccountDetails(
linked.owner.id); 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( const MapStringString accountDevices = ConfigurationManager::instance().getKnownRingDevices(
linked.owner.id); linked.owner.id);
auto it = accountDevices.begin(); auto it = accountDevices.begin();

8
src/libclient/directrenderer.cpp
View file

@ -56,7 +56,7 @@ public:
target.push = std::bind(&Impl::pushCallback, this, _1); target.push = std::bind(&Impl::pushCallback, this, _1);
}; };
DRing::FrameBuffer pullCallback() libjami::FrameBuffer pullCallback()
{ {
QMutexLocker lk(&mutex); QMutexLocker lk(&mutex);
if (!frameBufferPtr) { if (!frameBufferPtr) {
@ -75,7 +75,7 @@ public:
return std::move(frameBufferPtr); return std::move(frameBufferPtr);
}; };
void pushCallback(DRing::FrameBuffer buf) void pushCallback(libjami::FrameBuffer buf)
{ {
{ {
QMutexLocker lk(&mutex); QMutexLocker lk(&mutex);
@ -89,9 +89,9 @@ private:
DirectRenderer* parent_; DirectRenderer* parent_;
public: public:
DRing::SinkTarget target; libjami::SinkTarget target;
QMutex mutex; QMutex mutex;
DRing::FrameBuffer frameBufferPtr; libjami::FrameBuffer frameBufferPtr;
}; };
DirectRenderer::DirectRenderer(const QString& id, const QSize& res) 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); QStringList callLists = CallManager::instance().getCallList(accId);
for (const auto& call : callLists) { for (const auto& call : callLists) {
MapStringString callDetails = CallManager::instance().getCallDetails(accId, call); 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); result.push_back(call);
} }
} }
@ -215,12 +215,12 @@ Lrc::getConferences(const QString& accountId)
bool bool
isFinished(const QString& callState) isFinished(const QString& callState)
{ {
if (callState == QLatin1String(DRing::Call::StateEvent::HUNGUP) if (callState == QLatin1String(libjami::Call::StateEvent::HUNGUP)
|| callState == QLatin1String(DRing::Call::StateEvent::BUSY) || callState == QLatin1String(libjami::Call::StateEvent::BUSY)
|| callState == QLatin1String(DRing::Call::StateEvent::PEER_BUSY) || callState == QLatin1String(libjami::Call::StateEvent::PEER_BUSY)
|| callState == QLatin1String(DRing::Call::StateEvent::FAILURE) || callState == QLatin1String(libjami::Call::StateEvent::FAILURE)
|| callState == QLatin1String(DRing::Call::StateEvent::INACTIVE) || callState == QLatin1String(libjami::Call::StateEvent::INACTIVE)
|| callState == QLatin1String(DRing::Call::StateEvent::OVER)) { || callState == QLatin1String(libjami::Call::StateEvent::OVER)) {
return true; return true;
} }
return false; return false;

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

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

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

@ -32,25 +32,25 @@ InstanceManagerInterface::InstanceManagerInterface(bool muteDring)
using namespace std::placeholders; using namespace std::placeholders;
using std::bind; using std::bind;
using DRing::exportable_callback; using libjami::exportable_callback;
using DRing::CallSignal; using libjami::CallSignal;
using DRing::ConfigurationSignal; using libjami::ConfigurationSignal;
using DRing::PresenceSignal; using libjami::PresenceSignal;
using DRing::DataTransferSignal; using libjami::DataTransferSignal;
using DRing::ConversationSignal; using libjami::ConversationSignal;
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
using DRing::VideoSignal; using libjami::VideoSignal;
#endif #endif
#ifndef MUTE_DRING #ifndef MUTE_LIBJAMI
if (!muteDring) { if (!muteDring) {
ringFlags |= DRing::DRING_FLAG_DEBUG; ringFlags |= libjami::LIBJAMI_FLAG_DEBUG;
ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG; ringFlags |= libjami::LIBJAMI_FLAG_CONSOLE_LOG;
} }
#endif #endif
DRing::init(static_cast<DRing::InitFlag>(ringFlags)); libjami::init(static_cast<libjami::InitFlag>(ringFlags));
registerSignalHandlers(CallManager::instance().callHandlers); registerSignalHandlers(CallManager::instance().callHandlers);
registerSignalHandlers(ConfigurationManager::instance().confHandlers); registerSignalHandlers(ConfigurationManager::instance().confHandlers);
@ -61,7 +61,7 @@ InstanceManagerInterface::InstanceManagerInterface(bool muteDring)
#endif #endif
registerSignalHandlers(ConfigurationManager::instance().conversationsHandlers); registerSignalHandlers(ConfigurationManager::instance().conversationsHandlers);
if (!DRing::start()) if (!libjami::start())
printf("Error initializing daemon\n"); printf("Error initializing daemon\n");
else else
printf("Daemon is running\n"); 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) void Unregister(int pid)
{ {
Q_UNUSED(pid) // When directly linked, the PID is always the current process PID Q_UNUSED(pid) // When directly linked, the PID is always the current process PID
DRing::fini(); libjami::fini();
} }
bool isConnected(); bool isConnected();

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

@ -21,49 +21,49 @@
bool bool
PluginManagerInterface::loadPlugin(const QString& path) PluginManagerInterface::loadPlugin(const QString& path)
{ {
return DRing::loadPlugin(path.toStdString()); return libjami::loadPlugin(path.toStdString());
} }
bool bool
PluginManagerInterface::unloadPlugin(const QString& path) PluginManagerInterface::unloadPlugin(const QString& path)
{ {
return DRing::unloadPlugin(path.toStdString()); return libjami::unloadPlugin(path.toStdString());
} }
MapStringString MapStringString
PluginManagerInterface::getPluginDetails(const QString& path) PluginManagerInterface::getPluginDetails(const QString& path)
{ {
return convertMap(DRing::getPluginDetails(path.toStdString())); return convertMap(libjami::getPluginDetails(path.toStdString()));
} }
QStringList QStringList
PluginManagerInterface::getInstalledPlugins() PluginManagerInterface::getInstalledPlugins()
{ {
return convertStringList(DRing::getInstalledPlugins()); return convertStringList(libjami::getInstalledPlugins());
} }
QStringList QStringList
PluginManagerInterface::getLoadedPlugins() PluginManagerInterface::getLoadedPlugins()
{ {
return convertStringList(DRing::getLoadedPlugins()); return convertStringList(libjami::getLoadedPlugins());
} }
int int
PluginManagerInterface::installPlugin(const QString& jplPath, bool force) PluginManagerInterface::installPlugin(const QString& jplPath, bool force)
{ {
return DRing::installPlugin(jplPath.toStdString(), force); return libjami::installPlugin(jplPath.toStdString(), force);
} }
int int
PluginManagerInterface::uninstallPlugin(const QString& pluginRootPath) PluginManagerInterface::uninstallPlugin(const QString& pluginRootPath)
{ {
return DRing::uninstallPlugin(pluginRootPath.toStdString()); return libjami::uninstallPlugin(pluginRootPath.toStdString());
} }
QStringList QStringList
PluginManagerInterface::getCallMediaHandlers() PluginManagerInterface::getCallMediaHandlers()
{ {
return convertStringList(DRing::getCallMediaHandlers()); return convertStringList(libjami::getCallMediaHandlers());
} }
void void
@ -71,13 +71,13 @@ PluginManagerInterface::toggleCallMediaHandler(const QString& mediaHandlerId,
const QString& callId, const QString& callId,
bool toggle) bool toggle)
{ {
DRing::toggleCallMediaHandler(mediaHandlerId.toStdString(), callId.toStdString(), toggle); libjami::toggleCallMediaHandler(mediaHandlerId.toStdString(), callId.toStdString(), toggle);
} }
QStringList QStringList
PluginManagerInterface::getChatHandlers() PluginManagerInterface::getChatHandlers()
{ {
return convertStringList(DRing::getChatHandlers()); return convertStringList(libjami::getChatHandlers());
} }
void void
@ -86,54 +86,54 @@ PluginManagerInterface::toggleChatHandler(const QString& chatHandlerId,
const QString& peerId, const QString& peerId,
bool toggle) bool toggle)
{ {
DRing::toggleChatHandler(chatHandlerId.toStdString(), libjami::toggleChatHandler(chatHandlerId.toStdString(),
accountId.toStdString(), accountId.toStdString(),
peerId.toStdString(), peerId.toStdString(),
toggle); toggle);
} }
QStringList QStringList
PluginManagerInterface::getCallMediaHandlerStatus(const QString& callId) PluginManagerInterface::getCallMediaHandlerStatus(const QString& callId)
{ {
return convertStringList(DRing::getCallMediaHandlerStatus(callId.toStdString())); return convertStringList(libjami::getCallMediaHandlerStatus(callId.toStdString()));
} }
MapStringString MapStringString
PluginManagerInterface::getCallMediaHandlerDetails(const QString& mediaHandlerId) PluginManagerInterface::getCallMediaHandlerDetails(const QString& mediaHandlerId)
{ {
return convertMap(DRing::getCallMediaHandlerDetails(mediaHandlerId.toStdString())); return convertMap(libjami::getCallMediaHandlerDetails(mediaHandlerId.toStdString()));
} }
QStringList QStringList
PluginManagerInterface::getChatHandlerStatus(const QString& accountId, const QString& peerId) PluginManagerInterface::getChatHandlerStatus(const QString& accountId, const QString& peerId)
{ {
return convertStringList( return convertStringList(
DRing::getChatHandlerStatus(accountId.toStdString(), peerId.toStdString())); libjami::getChatHandlerStatus(accountId.toStdString(), peerId.toStdString()));
} }
MapStringString MapStringString
PluginManagerInterface::getChatHandlerDetails(const QString& chatHandlerId) PluginManagerInterface::getChatHandlerDetails(const QString& chatHandlerId)
{ {
return convertMap(DRing::getChatHandlerDetails(chatHandlerId.toStdString())); return convertMap(libjami::getChatHandlerDetails(chatHandlerId.toStdString()));
} }
void void
PluginManagerInterface::setPluginsEnabled(bool enable) PluginManagerInterface::setPluginsEnabled(bool enable)
{ {
DRing::setPluginsEnabled(enable); libjami::setPluginsEnabled(enable);
} }
bool bool
PluginManagerInterface::getPluginsEnabled() PluginManagerInterface::getPluginsEnabled()
{ {
return DRing::getPluginsEnabled(); return libjami::getPluginsEnabled();
} }
VectorMapStringString VectorMapStringString
PluginManagerInterface::getPluginPreferences(const QString& path, const QString& accountId) PluginManagerInterface::getPluginPreferences(const QString& path, const QString& accountId)
{ {
VectorMapStringString temp; 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)); temp.push_back(convertMap(x));
} }
return temp; return temp;
@ -145,21 +145,21 @@ PluginManagerInterface::setPluginPreference(const QString& path,
const QString& key, const QString& key,
const QString& value) const QString& value)
{ {
return DRing::setPluginPreference(path.toStdString(), return libjami::setPluginPreference(path.toStdString(),
accountId.toStdString(), accountId.toStdString(),
key.toStdString(), key.toStdString(),
value.toStdString()); value.toStdString());
} }
MapStringString MapStringString
PluginManagerInterface::getPluginPreferencesValues(const QString& path, const QString& accountId) PluginManagerInterface::getPluginPreferencesValues(const QString& path, const QString& accountId)
{ {
return convertMap( return convertMap(
DRing::getPluginPreferencesValues(path.toStdString(), accountId.toStdString())); libjami::getPluginPreferencesValues(path.toStdString(), accountId.toStdString()));
} }
bool bool
PluginManagerInterface::resetPluginPreferencesValues(const QString& path, const QString& accountId) 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 Q_OBJECT
public: public:
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> presHandlers; std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> presHandlers;
PresenceManagerInterface() PresenceManagerInterface()
{ {
using DRing::exportable_callback; using libjami::exportable_callback;
using DRing::PresenceSignal; using libjami::PresenceSignal;
presHandlers presHandlers
= {exportable_callback<PresenceSignal::NewServerSubscriptionRequest>( = {exportable_callback<PresenceSignal::NewServerSubscriptionRequest>(
@ -90,13 +90,13 @@ public:
public Q_SLOTS: // METHODS public Q_SLOTS: // METHODS
void answerServerRequest(const QString& uri, bool flag) void answerServerRequest(const QString& uri, bool flag)
{ {
DRing::answerServerRequest(uri.toStdString(), flag); libjami::answerServerRequest(uri.toStdString(), flag);
} }
VectorMapStringString getSubscriptions(const QString& accountID) VectorMapStringString getSubscriptions(const QString& accountID)
{ {
VectorMapStringString temp; VectorMapStringString temp;
for (auto x : DRing::getSubscriptions(accountID.toStdString())) { for (auto x : libjami::getSubscriptions(accountID.toStdString())) {
temp.push_back(convertMap(x)); temp.push_back(convertMap(x));
} }
return temp; return temp;
@ -104,17 +104,17 @@ public Q_SLOTS: // METHODS
void publish(const QString& accountID, bool status, const QString& note) 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) 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) 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 Q_SIGNALS: // SIGNALS

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

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

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

@ -50,14 +50,14 @@ public:
~VideoManagerInterface(); ~VideoManagerInterface();
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> videoHandlers; std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> videoHandlers;
#endif #endif
public Q_SLOTS: // METHODS public Q_SLOTS: // METHODS
void applySettings(const QString& name, MapStringString settings) void applySettings(const QString& name, MapStringString settings)
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
DRing::applySettings(name.toStdString(), convertMap(settings)); libjami::applySettings(name.toStdString(), convertMap(settings));
#else #else
Q_UNUSED(name) Q_UNUSED(name)
Q_UNUSED(settings) Q_UNUSED(settings)
@ -69,7 +69,7 @@ public Q_SLOTS: // METHODS
MapStringMapStringVectorString ret; MapStringMapStringVectorString ret;
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
std::map<std::string, std::map<std::string, std::vector<std::string>>> temp; 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) { for (auto& x : temp) {
QMap<QString, VectorString> ytemp; QMap<QString, VectorString> ytemp;
@ -87,7 +87,7 @@ public Q_SLOTS: // METHODS
QString getDefaultDevice() QString getDefaultDevice()
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
return QString::fromStdString(DRing::getDefaultDevice().c_str()); return QString::fromStdString(libjami::getDefaultDevice().c_str());
#else #else
return QString(); return QString();
#endif #endif
@ -96,7 +96,7 @@ public Q_SLOTS: // METHODS
QStringList getDeviceList() QStringList getDeviceList()
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
QStringList temp = convertStringList(DRing::getDeviceList()); QStringList temp = convertStringList(libjami::getDeviceList());
#else #else
QStringList temp; QStringList temp;
#endif #endif
@ -106,7 +106,7 @@ public Q_SLOTS: // METHODS
MapStringString getSettings(const QString& device) MapStringString getSettings(const QString& device)
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
MapStringString temp = convertMap(DRing::getSettings(device.toStdString())); MapStringString temp = convertMap(libjami::getSettings(device.toStdString()));
#else #else
Q_UNUSED(device) Q_UNUSED(device)
MapStringString temp; MapStringString temp;
@ -117,7 +117,7 @@ public Q_SLOTS: // METHODS
void setDefaultDevice(const QString& name) void setDefaultDevice(const QString& name)
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
DRing::setDefaultDevice(name.toStdString()); libjami::setDefaultDevice(name.toStdString());
#else #else
Q_UNUSED(name) Q_UNUSED(name)
#endif #endif
@ -126,25 +126,31 @@ public Q_SLOTS: // METHODS
QString openVideoInput(const QString& resource) QString openVideoInput(const QString& resource)
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
return DRing::openVideoInput(resource.toStdString()).c_str(); return libjami::openVideoInput(resource.toStdString()).c_str();
#endif #endif
} }
void closeVideoInput(const QString& resource) void closeVideoInput(const QString& resource)
{ {
#ifdef ENABLE_VIDEO #ifdef ENABLE_VIDEO
DRing::closeVideoInput(resource.toStdString()); libjami::closeVideoInput(resource.toStdString());
#endif #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 #ifdef ENABLE_VIDEO
return DRing::registerSinkTarget(sinkID.toStdString(), target); return libjami::registerSinkTarget(sinkID.toStdString(), target);
#else #else
Q_UNUSED(sinkID) Q_UNUSED(sinkID)
Q_UNUSED(target) Q_UNUSED(target)
@ -152,25 +158,40 @@ public Q_SLOTS: // METHODS
#endif #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) QString startLocalMediaRecorder(const QString& videoInputId, const QString& path)
{ {
return QString::fromStdString( return QString::fromStdString(
DRing::startLocalMediaRecorder(videoInputId.toStdString(), path.toStdString())); libjami::startLocalMediaRecorder(videoInputId.toStdString(), path.toStdString()));
} }
MapStringString getRenderer(const QString& id) MapStringString getRenderer(const QString& id)
{ {
return convertMap(DRing::getRenderer(id.toStdString())); return convertMap(libjami::getRenderer(id.toStdString()));
} }
Q_SIGNALS: // SIGNALS 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* TRUE_STR = "true";
constexpr static const char* FALSE_STR = "false"; constexpr static const char* FALSE_STR = "false";
// Adapted from libring DRing::DataTransferInfo // Adapted from libring libjami::DataTransferInfo
struct DataTransferInfo struct DataTransferInfo
{ {
QString accountId; QString accountId;