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

misc: rename DRing->libjami

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

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

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

28
src/app/avadapter.cpp
View file

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

32
src/app/calladapter.cpp
View file

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

17
src/libclient/accountmodel.cpp
View file

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

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

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

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

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

6
src/libclient/avmodel.cpp
View file

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

54
src/libclient/callbackshandler.cpp
View file

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

32
src/libclient/callmodel.cpp
View file

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

40
src/libclient/codecmodel.cpp
View file

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

6
src/libclient/contactmodel.cpp
View file

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

30
src/libclient/conversationmodel.cpp
View file

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

38
src/libclient/database.cpp
View file

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

30
src/libclient/datatransfermodel.cpp
View file

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

2
src/libclient/devicemodel.cpp
View file

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

8
src/libclient/directrenderer.cpp
View file

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

14
src/libclient/lrc.cpp
View file

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

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

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

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

@ -45,18 +45,18 @@ class ConfigurationManagerInterface : public QObject
Q_OBJECT
public:
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> confHandlers;
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> dataXferHandlers;
std::map<std::string, std::shared_ptr<DRing::CallbackWrapperBase>> conversationsHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> confHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> dataXferHandlers;
std::map<std::string, std::shared_ptr<libjami::CallbackWrapperBase>> conversationsHandlers;
ConfigurationManagerInterface()
{
setObjectName("ConfigurationManagerInterface");
using DRing::exportable_callback;
using DRing::ConfigurationSignal;
using DRing::AudioSignal;
using DRing::DataTransferSignal;
using DRing::ConversationSignal;
using libjami::exportable_callback;
using libjami::ConfigurationSignal;
using libjami::AudioSignal;
using libjami::DataTransferSignal;
using libjami::ConversationSignal;
setObjectName("ConfigurationManagerInterface");
confHandlers = {
@ -117,7 +117,7 @@ public:
QString(state.c_str()));
});
}),
exportable_callback<DRing::ConfigurationSignal::AccountMessageStatusChanged>(
exportable_callback<libjami::ConfigurationSignal::AccountMessageStatusChanged>(
[this](const std::string& account_id,
const std::string& conversation_id,
const std::string& peer,
@ -364,7 +364,7 @@ public:
public Q_SLOTS: // METHODS
QString addAccount(MapStringString details)
{
QString temp(DRing::addAccount(convertMap(details)).c_str());
QString temp(libjami::addAccount(convertMap(details)).c_str());
return temp;
}
@ -374,7 +374,7 @@ public Q_SLOTS: // METHODS
const QString& fileId,
const QString& path)
{
DRing::downloadFile(accountId.toStdString(),
libjami::downloadFile(accountId.toStdString(),
convId.toStdString(),
interactionId.toStdString(),
fileId.toStdString(),
@ -383,27 +383,27 @@ public Q_SLOTS: // METHODS
bool exportOnRing(const QString& accountID, const QString& password)
{
return DRing::exportOnRing(accountID.toStdString(), password.toStdString());
return libjami::exportOnRing(accountID.toStdString(), password.toStdString());
}
bool exportToFile(const QString& accountID,
const QString& destinationPath,
const QString& password = {})
{
return DRing::exportToFile(accountID.toStdString(),
return libjami::exportToFile(accountID.toStdString(),
destinationPath.toStdString(),
password.toStdString());
}
MapStringString getKnownRingDevices(const QString& accountID)
{
MapStringString temp = convertMap(DRing::getKnownRingDevices(accountID.toStdString()));
MapStringString temp = convertMap(libjami::getKnownRingDevices(accountID.toStdString()));
return temp;
}
bool lookupName(const QString& accountID, const QString& nameServiceURL, const QString& name)
{
return DRing::lookupName(accountID.toStdString(),
return libjami::lookupName(accountID.toStdString(),
nameServiceURL.toStdString(),
name.toStdString());
}
@ -412,78 +412,78 @@ public Q_SLOTS: // METHODS
const QString& nameServiceURL,
const QString& address)
{
return DRing::lookupAddress(accountID.toStdString(),
return libjami::lookupAddress(accountID.toStdString(),
nameServiceURL.toStdString(),
address.toStdString());
}
bool registerName(const QString& accountID, const QString& password, const QString& name)
{
return DRing::registerName(accountID.toStdString(),
return libjami::registerName(accountID.toStdString(),
password.toStdString(),
name.toStdString());
}
MapStringString getAccountDetails(const QString& accountID)
{
MapStringString temp = convertMap(DRing::getAccountDetails(accountID.toStdString()));
MapStringString temp = convertMap(libjami::getAccountDetails(accountID.toStdString()));
return temp;
}
QStringList getAccountList()
{
QStringList temp = convertStringList(DRing::getAccountList());
QStringList temp = convertStringList(libjami::getAccountList());
return temp;
}
MapStringString getAccountTemplate(const QString& accountType)
{
MapStringString temp = convertMap(DRing::getAccountTemplate(accountType.toStdString()));
MapStringString temp = convertMap(libjami::getAccountTemplate(accountType.toStdString()));
return temp;
}
// TODO: works?
VectorUInt getActiveCodecList(const QString& accountId)
{
std::vector<unsigned int> v = DRing::getActiveCodecList(accountId.toStdString());
std::vector<unsigned int> v = libjami::getActiveCodecList(accountId.toStdString());
return QVector<unsigned int>(v.begin(), v.end());
}
QString getAddrFromInterfaceName(const QString& interface)
{
QString temp(DRing::getAddrFromInterfaceName(interface.toStdString()).c_str());
QString temp(libjami::getAddrFromInterfaceName(interface.toStdString()).c_str());
return temp;
}
QStringList getAllIpInterface()
{
QStringList temp = convertStringList(DRing::getAllIpInterface());
QStringList temp = convertStringList(libjami::getAllIpInterface());
return temp;
}
QStringList getAllIpInterfaceByName()
{
QStringList temp = convertStringList(DRing::getAllIpInterfaceByName());
QStringList temp = convertStringList(libjami::getAllIpInterfaceByName());
return temp;
}
MapStringString getCodecDetails(const QString& accountID, int payload)
{
MapStringString temp = convertMap(
DRing::getCodecDetails(accountID.toStdString().c_str(), payload));
libjami::getCodecDetails(accountID.toStdString().c_str(), payload));
return temp;
}
VectorUInt getCodecList()
{
std::vector<unsigned int> v = DRing::getCodecList();
std::vector<unsigned int> v = libjami::getCodecList();
return QVector<unsigned int>(v.begin(), v.end());
}
VectorMapStringString getContacts(const QString& accountID)
{
VectorMapStringString temp;
for (const auto& x : DRing::getContacts(accountID.toStdString())) {
for (const auto& x : libjami::getContacts(accountID.toStdString())) {
temp.push_back(convertMap(x));
}
return temp;
@ -491,42 +491,42 @@ public Q_SLOTS: // METHODS
int getAudioInputDeviceIndex(const QString& devname)
{
return DRing::getAudioInputDeviceIndex(devname.toStdString());
return libjami::getAudioInputDeviceIndex(devname.toStdString());
}
QStringList getAudioInputDeviceList()
{
QStringList temp = convertStringList(DRing::getAudioInputDeviceList());
QStringList temp = convertStringList(libjami::getAudioInputDeviceList());
return temp;
}
QString getAudioManager()
{
QString temp(DRing::getAudioManager().c_str());
QString temp(libjami::getAudioManager().c_str());
return temp;
}
int getAudioOutputDeviceIndex(const QString& devname)
{
return DRing::getAudioOutputDeviceIndex(devname.toStdString());
return libjami::getAudioOutputDeviceIndex(devname.toStdString());
}
QStringList getAudioOutputDeviceList()
{
QStringList temp = convertStringList(DRing::getAudioOutputDeviceList());
QStringList temp = convertStringList(libjami::getAudioOutputDeviceList());
return temp;
}
QStringList getAudioPluginList()
{
QStringList temp = convertStringList(DRing::getAudioPluginList());
QStringList temp = convertStringList(libjami::getAudioPluginList());
return temp;
}
VectorMapStringString getCredentials(const QString& accountID)
{
VectorMapStringString temp;
for (auto x : DRing::getCredentials(accountID.toStdString())) {
for (auto x : libjami::getCredentials(accountID.toStdString())) {
temp.push_back(convertMap(x));
}
return temp;
@ -534,62 +534,62 @@ public Q_SLOTS: // METHODS
QStringList getCurrentAudioDevicesIndex()
{
QStringList temp = convertStringList(DRing::getCurrentAudioDevicesIndex());
QStringList temp = convertStringList(libjami::getCurrentAudioDevicesIndex());
return temp;
}
QString getCurrentAudioOutputPlugin()
{
QString temp(DRing::getCurrentAudioOutputPlugin().c_str());
QString temp(libjami::getCurrentAudioOutputPlugin().c_str());
return temp;
}
int getHistoryLimit()
{
return DRing::getHistoryLimit();
return libjami::getHistoryLimit();
}
bool getIsAlwaysRecording()
{
return DRing::getIsAlwaysRecording();
return libjami::getIsAlwaysRecording();
}
bool getNoiseSuppressState()
{
return DRing::getNoiseSuppressState();
return libjami::getNoiseSuppressState();
}
QString getRecordPath()
{
QString temp(DRing::getRecordPath().c_str());
QString temp(libjami::getRecordPath().c_str());
return temp;
}
bool getRecordPreview()
{
return DRing::getRecordPreview();
return libjami::getRecordPreview();
}
int getRecordQuality()
{
return DRing::getRecordQuality();
return libjami::getRecordQuality();
}
QStringList getSupportedAudioManagers()
{
return convertStringList(DRing::getSupportedAudioManagers());
return convertStringList(libjami::getSupportedAudioManagers());
}
QStringList getSupportedTlsMethod()
{
QStringList temp = convertStringList(DRing::getSupportedTlsMethod());
QStringList temp = convertStringList(libjami::getSupportedTlsMethod());
return temp;
}
MapStringString validateCertificate(const QString& unused, const QString& certificate)
{
MapStringString temp = convertMap(
DRing::validateCertificate(unused.toStdString(), certificate.toStdString()));
libjami::validateCertificate(unused.toStdString(), certificate.toStdString()));
return temp;
}
@ -600,7 +600,7 @@ public Q_SLOTS: // METHODS
const QString& caListPath)
{
MapStringString temp = convertMap(
DRing::validateCertificatePath(unused.toStdString(),
libjami::validateCertificatePath(unused.toStdString(),
certificate.toStdString(),
privateKey.toStdString(),
privateKeyPass.toStdString(),
@ -610,7 +610,7 @@ public Q_SLOTS: // METHODS
MapStringString getCertificateDetails(const QString& certificate)
{
MapStringString temp = convertMap(DRing::getCertificateDetails(certificate.toStdString()));
MapStringString temp = convertMap(libjami::getCertificateDetails(certificate.toStdString()));
return temp;
}
@ -619,7 +619,7 @@ public Q_SLOTS: // METHODS
const QString& privateKeyPass)
{
MapStringString temp = convertMap(
DRing::getCertificateDetailsPath(certificate.toStdString(),
libjami::getCertificateDetailsPath(certificate.toStdString(),
privateKey.toStdString(),
privateKeyPass.toStdString()));
return temp;
@ -627,124 +627,124 @@ public Q_SLOTS: // METHODS
QStringList getSupportedCiphers(const QString& accountID)
{
QStringList temp = convertStringList(DRing::getSupportedCiphers(accountID.toStdString()));
QStringList temp = convertStringList(libjami::getSupportedCiphers(accountID.toStdString()));
return temp;
}
double getVolume(const QString& device)
{
return DRing::getVolume(device.toStdString());
return libjami::getVolume(device.toStdString());
}
bool isAgcEnabled()
{
return DRing::isAgcEnabled();
return libjami::isAgcEnabled();
}
bool isCaptureMuted()
{
return DRing::isCaptureMuted();
return libjami::isCaptureMuted();
}
bool isDtmfMuted()
{
return DRing::isDtmfMuted();
return libjami::isDtmfMuted();
}
bool isPlaybackMuted()
{
return DRing::isPlaybackMuted();
return libjami::isPlaybackMuted();
}
void muteCapture(bool mute)
{
DRing::muteCapture(mute);
libjami::muteCapture(mute);
}
void muteDtmf(bool mute)
{
DRing::muteDtmf(mute);
libjami::muteDtmf(mute);
}
void mutePlayback(bool mute)
{
DRing::mutePlayback(mute);
libjami::mutePlayback(mute);
}
void registerAllAccounts()
{
DRing::registerAllAccounts();
libjami::registerAllAccounts();
}
void monitor(bool continuous)
{
DRing::monitor(continuous);
libjami::monitor(continuous);
}
void removeAccount(const QString& accountID)
{
DRing::removeAccount(accountID.toStdString());
libjami::removeAccount(accountID.toStdString());
}
bool changeAccountPassword(const QString& id,
const QString& currentPassword,
const QString& newPassword)
{
return DRing::changeAccountPassword(id.toStdString(),
return libjami::changeAccountPassword(id.toStdString(),
currentPassword.toStdString(),
newPassword.toStdString());
}
void sendRegister(const QString& accountID, bool enable)
{
DRing::sendRegister(accountID.toStdString(), enable);
libjami::sendRegister(accountID.toStdString(), enable);
}
void setAccountDetails(const QString& accountID, MapStringString details)
{
DRing::setAccountDetails(accountID.toStdString(), convertMap(details));
libjami::setAccountDetails(accountID.toStdString(), convertMap(details));
}
void setAccountsOrder(const QString& order)
{
DRing::setAccountsOrder(order.toStdString());
libjami::setAccountsOrder(order.toStdString());
}
void setActiveCodecList(const QString& accountID, VectorUInt& list)
{
// const std::vector<unsigned int> converted = convertStringList(list);
DRing::setActiveCodecList(accountID.toStdString(),
libjami::setActiveCodecList(accountID.toStdString(),
std::vector<unsigned>(list.begin(), list.end()));
}
void setAgcState(bool enabled)
{
DRing::setAgcState(enabled);
libjami::setAgcState(enabled);
}
void setAudioInputDevice(int index)
{
DRing::setAudioInputDevice(index);
libjami::setAudioInputDevice(index);
}
bool setAudioManager(const QString& api)
{
return DRing::setAudioManager(api.toStdString());
return libjami::setAudioManager(api.toStdString());
}
void setAudioOutputDevice(int index)
{
DRing::setAudioOutputDevice(index);
libjami::setAudioOutputDevice(index);
}
void setAudioPlugin(const QString& audioPlugin)
{
DRing::setAudioPlugin(audioPlugin.toStdString());
libjami::setAudioPlugin(audioPlugin.toStdString());
}
void setAudioRingtoneDevice(int index)
{
DRing::setAudioRingtoneDevice(index);
libjami::setAudioRingtoneDevice(index);
}
void setCredentials(const QString& accountID, VectorMapStringString credentialInformation)
@ -753,97 +753,98 @@ public Q_SLOTS: // METHODS
for (auto x : credentialInformation) {
temp.push_back(convertMap(x));
}
DRing::setCredentials(accountID.toStdString(), temp);
libjami::setCredentials(accountID.toStdString(), temp);
}
void setHistoryLimit(int days)
{
DRing::setHistoryLimit(days);
libjami::setHistoryLimit(days);
}
void setIsAlwaysRecording(bool enabled)
{
DRing::setIsAlwaysRecording(enabled);
libjami::setIsAlwaysRecording(enabled);
}
void setNoiseSuppressState(bool state)
{
DRing::setNoiseSuppressState(state);
libjami::setNoiseSuppressState(state);
}
bool isAudioMeterActive(const QString& id)
{
return DRing::isAudioMeterActive(id.toStdString());
return libjami::isAudioMeterActive(id.toStdString());
}
void setAudioMeterState(const QString& id, bool state)
{
DRing::setAudioMeterState(id.toStdString(), state);
libjami::setAudioMeterState(id.toStdString(), state);
}
void setRecordPath(const QString& rec)
{
DRing::setRecordPath(rec.toStdString());
libjami::setRecordPath(rec.toStdString());
}
void setRecordPreview(const bool& rec)
{
DRing::setRecordPreview(rec);
libjami::setRecordPreview(rec);
}
void setRecordQuality(const int& quality)
{
DRing::setRecordQuality(quality);
libjami::setRecordQuality(quality);
}
void setVolume(const QString& device, double value)
{
DRing::setVolume(device.toStdString(), value);
libjami::setVolume(device.toStdString(), value);
}
MapStringString getVolatileAccountDetails(const QString& accountID)
{
MapStringString temp = convertMap(DRing::getVolatileAccountDetails(accountID.toStdString()));
MapStringString temp = convertMap(
libjami::getVolatileAccountDetails(accountID.toStdString()));
return temp;
}
QStringList getPinnedCertificates()
{
QStringList temp = convertStringList(DRing::getPinnedCertificates());
QStringList temp = convertStringList(libjami::getPinnedCertificates());
return temp;
}
QStringList pinCertificate(const QByteArray& content, bool local)
{
std::vector<unsigned char> raw(content.begin(), content.end());
return convertStringList(DRing::pinCertificate(raw, local));
return convertStringList(libjami::pinCertificate(raw, local));
}
bool unpinCertificate(const QString& certId)
{
return DRing::unpinCertificate(certId.toStdString());
return libjami::unpinCertificate(certId.toStdString());
}
void pinCertificatePath(const QString& certPath)
{
DRing::pinCertificatePath(certPath.toStdString());
libjami::pinCertificatePath(certPath.toStdString());
}
uint unpinCertificatePath(const QString& certPath)
{
return DRing::unpinCertificatePath(certPath.toStdString());
return libjami::unpinCertificatePath(certPath.toStdString());
}
bool pinRemoteCertificate(const QString& accountId, const QString& certPath)
{
return DRing::pinRemoteCertificate(accountId.toStdString(), certPath.toStdString());
return libjami::pinRemoteCertificate(accountId.toStdString(), certPath.toStdString());
}
bool setCertificateStatus(const QString& accountId,
const QString& certPath,
const QString& status)
{
return DRing::setCertificateStatus(accountId.toStdString(),
return libjami::setCertificateStatus(accountId.toStdString(),
certPath.toStdString(),
status.toStdString());
}
@ -851,50 +852,52 @@ public Q_SLOTS: // METHODS
QStringList getCertificatesByStatus(const QString& accountId, const QString& status)
{
return convertStringList(
DRing::getCertificatesByStatus(accountId.toStdString(), status.toStdString()));
libjami::getCertificatesByStatus(accountId.toStdString(), status.toStdString()));
}
VectorMapStringString getTrustRequests(const QString& accountId)
{
return convertVecMap(DRing::getTrustRequests(accountId.toStdString()));
return convertVecMap(libjami::getTrustRequests(accountId.toStdString()));
}
bool acceptTrustRequest(const QString& accountId, const QString& from)
{
return DRing::acceptTrustRequest(accountId.toStdString(), from.toStdString());
return libjami::acceptTrustRequest(accountId.toStdString(), from.toStdString());
}
bool discardTrustRequest(const QString& accountId, const QString& from)
{
return DRing::discardTrustRequest(accountId.toStdString(), from.toStdString());
return libjami::discardTrustRequest(accountId.toStdString(), from.toStdString());
}
void sendTrustRequest(const QString& accountId, const QString& from, const QByteArray& payload)
{
std::vector<unsigned char> raw(payload.begin(), payload.end());
DRing::sendTrustRequest(accountId.toStdString(), from.toStdString(), raw);
libjami::sendTrustRequest(accountId.toStdString(), from.toStdString(), raw);
}
void removeContact(const QString& accountId, const QString& uri, bool ban)
{
DRing::removeContact(accountId.toStdString(), uri.toStdString(), ban);
libjami::removeContact(accountId.toStdString(), uri.toStdString(), ban);
}
void revokeDevice(const QString& accountId, const QString& password, const QString& deviceId)
{
DRing::revokeDevice(accountId.toStdString(), password.toStdString(), deviceId.toStdString());
libjami::revokeDevice(accountId.toStdString(),
password.toStdString(),
deviceId.toStdString());
}
void addContact(const QString& accountId, const QString& uri)
{
DRing::addContact(accountId.toStdString(), uri.toStdString());
libjami::addContact(accountId.toStdString(), uri.toStdString());
}
uint64_t sendTextMessage(const QString& accountId,
const QString& to,
const QMap<QString, QString>& payloads)
{
return DRing::sendAccountTextMessage(accountId.toStdString(),
return libjami::sendAccountTextMessage(accountId.toStdString(),
to.toStdString(),
convertMap(payloads));
}
@ -902,7 +905,7 @@ public Q_SLOTS: // METHODS
QVector<Message> getLastMessages(const QString& accountID, const uint64_t& base_timestamp)
{
QVector<Message> result;
for (auto& message : DRing::getLastMessages(accountID.toStdString(), base_timestamp)) {
for (auto& message : libjami::getLastMessages(accountID.toStdString(), base_timestamp)) {
result.append({message.from.c_str(), convertMap(message.payloads), message.received});
}
return result;
@ -912,27 +915,27 @@ public Q_SLOTS: // METHODS
unsigned int codecId,
const MapStringString& details)
{
return DRing::setCodecDetails(accountId.toStdString(), codecId, convertMap(details));
return libjami::setCodecDetails(accountId.toStdString(), codecId, convertMap(details));
}
int getMessageStatus(uint64_t id)
{
return DRing::getMessageStatus(id);
return libjami::getMessageStatus(id);
}
MapStringString getNearbyPeers(const QString& accountID)
{
return convertMap(DRing::getNearbyPeers(accountID.toStdString()));
return convertMap(libjami::getNearbyPeers(accountID.toStdString()));
}
void connectivityChanged()
{
DRing::connectivityChanged();
libjami::connectivityChanged();
}
MapStringString getContactDetails(const QString& accountID, const QString& uri)
{
return convertMap(DRing::getContactDetails(accountID.toStdString(), uri.toStdString()));
return convertMap(libjami::getContactDetails(accountID.toStdString(), uri.toStdString()));
}
void sendFile(const QString& accountId,
@ -941,7 +944,7 @@ public Q_SLOTS: // METHODS
const QString& fileDisplayName,
const QString& parent)
{
DRing::sendFile(accountId.toStdString(),
libjami::sendFile(accountId.toStdString(),
conversationId.toStdString(),
filePath.toStdString(),
fileDisplayName.toStdString(),
@ -956,7 +959,7 @@ public Q_SLOTS: // METHODS
qlonglong& progress)
{
std::string pathstr;
auto result = uint32_t(DRing::fileTransferInfo(accountId.toStdString(),
auto result = uint32_t(libjami::fileTransferInfo(accountId.toStdString(),
conversationId.toStdString(),
fileId.toStdString(),
pathstr,
@ -968,24 +971,24 @@ public Q_SLOTS: // METHODS
uint32_t cancelDataTransfer(QString accountId, QString conversationId, QString transfer_id)
{
return uint32_t(DRing::cancelDataTransfer(accountId.toStdString(),
return uint32_t(libjami::cancelDataTransfer(accountId.toStdString(),
conversationId.toStdString(),
transfer_id.toStdString()));
}
void setPushNotificationToken(const QString& token)
{
DRing::setPushNotificationToken(token.toStdString());
libjami::setPushNotificationToken(token.toStdString());
}
void pushNotificationReceived(const QString& from, const MapStringString& data)
{
DRing::pushNotificationReceived(from.toStdString(), convertMap(data));
libjami::pushNotificationReceived(from.toStdString(), convertMap(data));
}
void setIsComposing(const QString& accountId, const QString& contactId, bool isComposing)
{
DRing::setIsComposing(accountId.toStdString(), contactId.toStdString(), isComposing);
libjami::setIsComposing(accountId.toStdString(), contactId.toStdString(), isComposing);
}
bool setMessageDisplayed(const QString& accountId,
@ -993,7 +996,7 @@ public Q_SLOTS: // METHODS
const QString& messageId,
int status)
{
return DRing::setMessageDisplayed(accountId.toStdString(),
return libjami::setMessageDisplayed(accountId.toStdString(),
contactId.toStdString(),
messageId.toStdString(),
status);
@ -1001,41 +1004,41 @@ public Q_SLOTS: // METHODS
bool searchUser(const QString& accountId, const QString& query)
{
return DRing::searchUser(accountId.toStdString(), query.toStdString());
return libjami::searchUser(accountId.toStdString(), query.toStdString());
}
// swarm
QString startConversation(const QString& accountId)
{
auto convId = DRing::startConversation(accountId.toStdString());
auto convId = libjami::startConversation(accountId.toStdString());
return QString(convId.c_str());
}
void acceptConversationRequest(const QString& accountId, const QString& conversationId)
{
DRing::acceptConversationRequest(accountId.toStdString(), conversationId.toStdString());
libjami::acceptConversationRequest(accountId.toStdString(), conversationId.toStdString());
}
void declineConversationRequest(const QString& accountId, const QString& conversationId)
{
DRing::declineConversationRequest(accountId.toStdString(), conversationId.toStdString());
libjami::declineConversationRequest(accountId.toStdString(), conversationId.toStdString());
}
bool removeConversation(const QString& accountId, const QString& conversationId)
{
return DRing::removeConversation(accountId.toStdString(), conversationId.toStdString());
return libjami::removeConversation(accountId.toStdString(), conversationId.toStdString());
}
QStringList getConversations(const QString& accountId)
{
auto conversations = DRing::getConversations(accountId.toStdString());
auto conversations = libjami::getConversations(accountId.toStdString());
return convertStringList(conversations);
}
VectorMapStringString getConversationRequests(const QString& accountId)
{
auto requests = DRing::getConversationRequests(accountId.toStdString());
auto requests = libjami::getConversationRequests(accountId.toStdString());
return convertVecMap(requests);
}
void addConversationMember(const QString& accountId,
const QString& conversationId,
const QString& memberId)
{
DRing::addConversationMember(accountId.toStdString(),
libjami::addConversationMember(accountId.toStdString(),
conversationId.toStdString(),
memberId.toStdString());
}
@ -1043,14 +1046,14 @@ public Q_SLOTS: // METHODS
const QString& conversationId,
const QString& memberId)
{
DRing::removeConversationMember(accountId.toStdString(),
libjami::removeConversationMember(accountId.toStdString(),
conversationId.toStdString(),
memberId.toStdString());
}
VectorMapStringString getConversationMembers(const QString& accountId,
const QString& conversationId)
{
auto members = DRing::getConversationMembers(accountId.toStdString(),
auto members = libjami::getConversationMembers(accountId.toStdString(),
conversationId.toStdString());
return convertVecMap(members);
}
@ -1060,7 +1063,7 @@ public Q_SLOTS: // METHODS
const QString& parent,
int flags = 0)
{
DRing::sendMessage(accountId.toStdString(),
libjami::sendMessage(accountId.toStdString(),
conversationId.toStdString(),
message.toStdString(),
parent.toStdString(),
@ -1072,7 +1075,7 @@ public Q_SLOTS: // METHODS
const QString& fromId,
const int size)
{
return DRing::loadConversationMessages(accountId.toStdString(),
return libjami::loadConversationMessages(accountId.toStdString(),
conversationId.toStdString(),
fromId.toStdString(),
size);
@ -1082,7 +1085,7 @@ public Q_SLOTS: // METHODS
const QString& fromId,
const QString& toId)
{
return DRing::loadConversationUntil(accountId.toStdString(),
return libjami::loadConversationUntil(accountId.toStdString(),
conversationId.toStdString(),
fromId.toStdString(),
toId.toStdString());
@ -1090,44 +1093,44 @@ public Q_SLOTS: // METHODS
void setDefaultModerator(const QString& accountID, const QString& peerURI, const bool& state)
{
DRing::setDefaultModerator(accountID.toStdString(), peerURI.toStdString(), state);
libjami::setDefaultModerator(accountID.toStdString(), peerURI.toStdString(), state);
}
QStringList getDefaultModerators(const QString& accountID)
{
return convertStringList(DRing::getDefaultModerators(accountID.toStdString()));
return convertStringList(libjami::getDefaultModerators(accountID.toStdString()));
}
void enableLocalModerators(const QString& accountID, const bool& isModEnabled)
{
DRing::enableLocalModerators(accountID.toStdString(), isModEnabled);
libjami::enableLocalModerators(accountID.toStdString(), isModEnabled);
}
bool isLocalModeratorsEnabled(const QString& accountID)
{
return DRing::isLocalModeratorsEnabled(accountID.toStdString());
return libjami::isLocalModeratorsEnabled(accountID.toStdString());
}
void setAllModerators(const QString& accountID, const bool& allModerators)
{
DRing::setAllModerators(accountID.toStdString(), allModerators);
libjami::setAllModerators(accountID.toStdString(), allModerators);
}
bool isAllModerators(const QString& accountID)
{
return DRing::isAllModerators(accountID.toStdString());
return libjami::isAllModerators(accountID.toStdString());
}
MapStringString conversationInfos(const QString& accountId, const QString& conversationId)
{
return convertMap(
DRing::conversationInfos(accountId.toStdString(), conversationId.toStdString()));
libjami::conversationInfos(accountId.toStdString(), conversationId.toStdString()));
}
MapStringString getConversationPreferences(const QString& accountId,
const QString& conversationId)
{
return convertMap(DRing::getConversationPreferences(accountId.toStdString(),
return convertMap(libjami::getConversationPreferences(accountId.toStdString(),
conversationId.toStdString()));
}
@ -1135,7 +1138,7 @@ public Q_SLOTS: // METHODS
const QString& conversationId,
const MapStringString& info)
{
DRing::updateConversationInfos(accountId.toStdString(),
libjami::updateConversationInfos(accountId.toStdString(),
conversationId.toStdString(),
convertMap(info));
}
@ -1144,7 +1147,7 @@ public Q_SLOTS: // METHODS
const QString& conversationId,
const MapStringString& prefs)
{
DRing::setConversationPreferences(accountId.toStdString(),
libjami::setConversationPreferences(accountId.toStdString(),
conversationId.toStdString(),
convertMap(prefs));
}
@ -1155,7 +1158,7 @@ public Q_SLOTS: // METHODS
const QString& fromId,
const QString& authorUri)
{
return DRing::countInteractions(accountId.toStdString(),
return libjami::countInteractions(accountId.toStdString(),
conversationId.toStdString(),
toId.toStdString(),
fromId.toStdString(),
@ -1171,7 +1174,7 @@ public Q_SLOTS: // METHODS
const int64_t& before,
const uint32_t& maxResult)
{
return DRing::searchConversation(accountId.toStdString(),
return libjami::searchConversation(accountId.toStdString(),
conversationId.toStdString(),
author.toStdString(),
lastId.toStdString(),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
src/libclient/typedefs.h
View file

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