mirror of
https://git.jami.net/savoirfairelinux/jami-daemon.git
synced 2025-08-07 22:02:12 +08:00
e4cca14861
Else, we can see several deadlock (closeVideoInput() will wait forever, because a signal is emitted before the method is finished causing a deadlock in sdbus-cpp) Change-Id: I87d5a5d51e80f3b75e60354595f8c618def361ff
1139 lines
38 KiB
C++
1139 lines
38 KiB
C++
/*
|
|
* Copyright (C) 2004-2023 Savoir-faire Linux Inc.
|
|
*
|
|
* Author: Philippe Proulx <philippe.proulx@savoirfairelinux.com>
|
|
* Author: Vladimir Stoiakin <vstoiakin@lavabit.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "dbusconfigurationmanager.adaptor.h"
|
|
#include <configurationmanager_interface.h>
|
|
#include <datatransfer_interface.h>
|
|
#include <conversation_interface.h>
|
|
|
|
class DBusConfigurationManager : public sdbus::AdaptorInterfaces<cx::ring::Ring::ConfigurationManager_adaptor>
|
|
{
|
|
public:
|
|
DBusConfigurationManager(sdbus::IConnection& connection)
|
|
: AdaptorInterfaces(connection, "/cx/ring/Ring/ConfigurationManager")
|
|
{
|
|
registerAdaptor();
|
|
registerSignalHandlers();
|
|
}
|
|
|
|
~DBusConfigurationManager()
|
|
{
|
|
unregisterAdaptor();
|
|
}
|
|
|
|
auto
|
|
getAccountDetails(const std::string& accountID)
|
|
-> decltype(libjami::getAccountDetails(accountID))
|
|
{
|
|
return libjami::getAccountDetails(accountID);
|
|
}
|
|
|
|
auto
|
|
getVolatileAccountDetails(const std::string& accountID)
|
|
-> decltype(libjami::getVolatileAccountDetails(accountID))
|
|
{
|
|
return libjami::getVolatileAccountDetails(accountID);
|
|
}
|
|
|
|
void
|
|
setAccountDetails(const std::string& accountID,
|
|
const std::map<std::string, std::string>& details)
|
|
{
|
|
libjami::setAccountDetails(accountID, details);
|
|
}
|
|
|
|
void
|
|
setAccountActive(const std::string& accountID, const bool& active)
|
|
{
|
|
libjami::setAccountActive(accountID, active);
|
|
}
|
|
|
|
auto
|
|
getAccountTemplate(const std::string& accountType)
|
|
-> decltype(libjami::getAccountTemplate(accountType))
|
|
{
|
|
return libjami::getAccountTemplate(accountType);
|
|
}
|
|
|
|
auto
|
|
addAccount(const std::map<std::string, std::string>& details)
|
|
-> decltype(libjami::addAccount(details))
|
|
{
|
|
return libjami::addAccount(details);
|
|
}
|
|
|
|
auto
|
|
monitor(const bool& continuous) -> decltype(libjami::monitor(continuous))
|
|
{
|
|
return libjami::monitor(continuous);
|
|
}
|
|
|
|
auto
|
|
exportOnRing(const std::string& accountID, const std::string& password)
|
|
-> decltype(libjami::exportOnRing(accountID, password))
|
|
{
|
|
return libjami::exportOnRing(accountID, password);
|
|
}
|
|
|
|
auto
|
|
exportToFile(const std::string& accountID,
|
|
const std::string& destinationPath,
|
|
const std::string& password)
|
|
-> decltype(libjami::exportToFile(accountID, destinationPath, password))
|
|
{
|
|
return libjami::exportToFile(accountID, destinationPath, password);
|
|
}
|
|
|
|
auto
|
|
revokeDevice(const std::string& accountID,
|
|
const std::string& password,
|
|
const std::string& device)
|
|
-> decltype(libjami::revokeDevice(accountID, password, device))
|
|
{
|
|
return libjami::revokeDevice(accountID, password, device);
|
|
}
|
|
|
|
auto
|
|
getKnownRingDevices(const std::string& accountID)
|
|
-> decltype(libjami::getKnownRingDevices(accountID))
|
|
{
|
|
return libjami::getKnownRingDevices(accountID);
|
|
}
|
|
|
|
auto
|
|
changeAccountPassword(const std::string& accountID,
|
|
const std::string& password_old,
|
|
const std::string& password_new)
|
|
-> decltype(libjami::changeAccountPassword(accountID, password_old, password_new))
|
|
{
|
|
return libjami::changeAccountPassword(accountID, password_old, password_new);
|
|
}
|
|
|
|
auto
|
|
lookupName(const std::string& account,
|
|
const std::string& nameserver,
|
|
const std::string& name)
|
|
-> decltype(libjami::lookupName(account, nameserver, name))
|
|
{
|
|
return libjami::lookupName(account, nameserver, name);
|
|
}
|
|
|
|
auto
|
|
lookupAddress(const std::string& account,
|
|
const std::string& nameserver,
|
|
const std::string& address)
|
|
-> decltype(libjami::lookupAddress(account, nameserver, address))
|
|
{
|
|
return libjami::lookupAddress(account, nameserver, address);
|
|
}
|
|
|
|
auto
|
|
registerName(const std::string& account,
|
|
const std::string& password,
|
|
const std::string& name)
|
|
-> decltype(libjami::registerName(account, password, name))
|
|
{
|
|
return libjami::registerName(account, password, name);
|
|
}
|
|
|
|
auto
|
|
searchUser(const std::string& account, const std::string& query)
|
|
-> decltype(libjami::searchUser(account, query))
|
|
{
|
|
return libjami::searchUser(account, query);
|
|
}
|
|
|
|
void
|
|
removeAccount(const std::string& accountID)
|
|
{
|
|
libjami::removeAccount(accountID);
|
|
}
|
|
|
|
auto
|
|
getAccountList() -> decltype(libjami::getAccountList())
|
|
{
|
|
return libjami::getAccountList();
|
|
}
|
|
|
|
void
|
|
sendRegister(const std::string& accountID, const bool& enable)
|
|
{
|
|
libjami::sendRegister(accountID, enable);
|
|
}
|
|
|
|
void
|
|
registerAllAccounts(void)
|
|
{
|
|
libjami::registerAllAccounts();
|
|
}
|
|
|
|
auto
|
|
sendTextMessage(const std::string& accountID,
|
|
const std::string& to,
|
|
const std::map<std::string, std::string>& payloads,
|
|
const int32_t& flags)
|
|
-> decltype(libjami::sendAccountTextMessage(accountID, to, payloads, flags))
|
|
{
|
|
return libjami::sendAccountTextMessage(accountID, to, payloads, flags);
|
|
}
|
|
|
|
std::vector<sdbus::Struct<std::string, std::map<std::string, std::string>, uint64_t>>
|
|
getLastMessages(const std::string& accountID,
|
|
const uint64_t& base_timestamp)
|
|
{
|
|
auto messages = libjami::getLastMessages(accountID, base_timestamp);
|
|
std::vector<sdbus::Struct<std::string, std::map<std::string, std::string>, uint64_t>> result;
|
|
for (const auto& message : messages) {
|
|
sdbus::Struct<std::string, std::map<std::string, std::string>, uint64_t> m(
|
|
message.from, message.payloads, message.received );
|
|
result.emplace_back(m);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::map<std::string, std::string>
|
|
getNearbyPeers(const std::string& accountID)
|
|
{
|
|
return libjami::getNearbyPeers(accountID);
|
|
}
|
|
|
|
auto
|
|
getMessageStatus(const uint64_t& id)
|
|
-> decltype(libjami::getMessageStatus(id))
|
|
{
|
|
return libjami::getMessageStatus(id);
|
|
}
|
|
|
|
auto
|
|
getMessageStatus(const std::string& accountID, const uint64_t& id)
|
|
-> decltype(libjami::getMessageStatus(accountID, id))
|
|
{
|
|
return libjami::getMessageStatus(accountID, id);
|
|
}
|
|
|
|
bool
|
|
cancelMessage(const std::string& accountID, const uint64_t& id)
|
|
{
|
|
return libjami::cancelMessage(accountID, id);
|
|
}
|
|
|
|
void
|
|
setIsComposing(const std::string& accountID,
|
|
const std::string& conversationUri,
|
|
const bool& isWriting)
|
|
{
|
|
libjami::setIsComposing(accountID, conversationUri, isWriting);
|
|
}
|
|
|
|
bool
|
|
setMessageDisplayed(const std::string& accountID,
|
|
const std::string& conversationUri,
|
|
const std::string& messageId,
|
|
const int32_t& status)
|
|
{
|
|
return libjami::setMessageDisplayed(accountID, conversationUri, messageId, status);
|
|
}
|
|
|
|
auto
|
|
getCodecList() -> decltype(libjami::getCodecList())
|
|
{
|
|
return libjami::getCodecList();
|
|
}
|
|
|
|
auto
|
|
getSupportedTlsMethod() -> decltype(libjami::getSupportedTlsMethod())
|
|
{
|
|
return libjami::getSupportedTlsMethod();
|
|
}
|
|
|
|
auto
|
|
getSupportedCiphers(const std::string& accountID)
|
|
-> decltype(libjami::getSupportedCiphers(accountID))
|
|
{
|
|
return libjami::getSupportedCiphers(accountID);
|
|
}
|
|
|
|
auto
|
|
getCodecDetails(const std::string& accountID, const unsigned& codecId)
|
|
-> decltype(libjami::getCodecDetails(accountID, codecId))
|
|
{
|
|
return libjami::getCodecDetails(accountID, codecId);
|
|
}
|
|
|
|
auto
|
|
setCodecDetails(const std::string& accountID,
|
|
const unsigned& codecId,
|
|
const std::map<std::string, std::string>& details)
|
|
-> decltype(libjami::setCodecDetails(accountID, codecId, details))
|
|
{
|
|
return libjami::setCodecDetails(accountID, codecId, details);
|
|
}
|
|
|
|
auto
|
|
getActiveCodecList(const std::string& accountID)
|
|
-> decltype(libjami::getActiveCodecList(accountID))
|
|
{
|
|
return libjami::getActiveCodecList(accountID);
|
|
}
|
|
|
|
void
|
|
setActiveCodecList(const std::string& accountID,
|
|
const std::vector<unsigned>& list)
|
|
{
|
|
libjami::setActiveCodecList(accountID, list);
|
|
}
|
|
|
|
auto
|
|
getAudioPluginList() -> decltype(libjami::getAudioPluginList())
|
|
{
|
|
return libjami::getAudioPluginList();
|
|
}
|
|
|
|
void
|
|
setAudioPlugin(const std::string& audioPlugin)
|
|
{
|
|
libjami::setAudioPlugin(audioPlugin);
|
|
}
|
|
|
|
auto
|
|
getAudioOutputDeviceList()
|
|
-> decltype(libjami::getAudioOutputDeviceList())
|
|
{
|
|
return libjami::getAudioOutputDeviceList();
|
|
}
|
|
|
|
void
|
|
setAudioOutputDevice(const int32_t& index)
|
|
{
|
|
libjami::setAudioOutputDevice(index);
|
|
}
|
|
|
|
void
|
|
setAudioInputDevice(const int32_t& index)
|
|
{
|
|
libjami::setAudioInputDevice(index);
|
|
}
|
|
|
|
void
|
|
setAudioRingtoneDevice(const int32_t& index)
|
|
{
|
|
libjami::setAudioRingtoneDevice(index);
|
|
}
|
|
|
|
auto
|
|
getAudioInputDeviceList() -> decltype(libjami::getAudioInputDeviceList())
|
|
{
|
|
return libjami::getAudioInputDeviceList();
|
|
}
|
|
|
|
auto
|
|
getCurrentAudioDevicesIndex()
|
|
-> decltype(libjami::getCurrentAudioDevicesIndex())
|
|
{
|
|
return libjami::getCurrentAudioDevicesIndex();
|
|
}
|
|
|
|
auto
|
|
getAudioInputDeviceIndex(const std::string& name)
|
|
-> decltype(libjami::getAudioInputDeviceIndex(name))
|
|
{
|
|
return libjami::getAudioInputDeviceIndex(name);
|
|
}
|
|
|
|
auto
|
|
getAudioOutputDeviceIndex(const std::string& name)
|
|
-> decltype(libjami::getAudioOutputDeviceIndex(name))
|
|
{
|
|
return libjami::getAudioOutputDeviceIndex(name);
|
|
}
|
|
|
|
auto
|
|
getCurrentAudioOutputPlugin()
|
|
-> decltype(libjami::getCurrentAudioOutputPlugin())
|
|
{
|
|
return libjami::getCurrentAudioOutputPlugin();
|
|
}
|
|
|
|
auto
|
|
getNoiseSuppressState() -> decltype(libjami::getNoiseSuppressState())
|
|
{
|
|
return libjami::getNoiseSuppressState();
|
|
}
|
|
|
|
void
|
|
setNoiseSuppressState(const std::string& state)
|
|
{
|
|
libjami::setNoiseSuppressState(state);
|
|
}
|
|
|
|
auto
|
|
isAgcEnabled() -> decltype(libjami::isAgcEnabled())
|
|
{
|
|
return libjami::isAgcEnabled();
|
|
}
|
|
|
|
void
|
|
setAgcState(const bool& enabled)
|
|
{
|
|
libjami::setAgcState(enabled);
|
|
}
|
|
|
|
void
|
|
muteDtmf(const bool& mute)
|
|
{
|
|
libjami::muteDtmf(mute);
|
|
}
|
|
|
|
auto
|
|
isDtmfMuted() -> decltype(libjami::isDtmfMuted())
|
|
{
|
|
return libjami::isDtmfMuted();
|
|
}
|
|
|
|
auto
|
|
isCaptureMuted() -> decltype(libjami::isCaptureMuted())
|
|
{
|
|
return libjami::isCaptureMuted();
|
|
}
|
|
|
|
void
|
|
muteCapture(const bool& mute)
|
|
{
|
|
libjami::muteCapture(mute);
|
|
}
|
|
|
|
auto
|
|
isPlaybackMuted() -> decltype(libjami::isPlaybackMuted())
|
|
{
|
|
return libjami::isPlaybackMuted();
|
|
}
|
|
|
|
void
|
|
mutePlayback(const bool& mute)
|
|
{
|
|
libjami::mutePlayback(mute);
|
|
}
|
|
|
|
auto
|
|
isRingtoneMuted() -> decltype(libjami::isRingtoneMuted())
|
|
{
|
|
return libjami::isRingtoneMuted();
|
|
}
|
|
|
|
void
|
|
muteRingtone(const bool& mute)
|
|
{
|
|
libjami::muteRingtone(mute);
|
|
}
|
|
|
|
auto
|
|
getAudioManager() -> decltype(libjami::getAudioManager())
|
|
{
|
|
return libjami::getAudioManager();
|
|
}
|
|
|
|
auto
|
|
setAudioManager(const std::string& api)
|
|
-> decltype(libjami::setAudioManager(api))
|
|
{
|
|
return libjami::setAudioManager(api);
|
|
}
|
|
|
|
auto
|
|
getSupportedAudioManagers()
|
|
-> decltype(libjami::getSupportedAudioManagers())
|
|
{
|
|
return libjami::getSupportedAudioManagers();
|
|
}
|
|
|
|
auto
|
|
getRecordPath() -> decltype(libjami::getRecordPath())
|
|
{
|
|
return libjami::getRecordPath();
|
|
}
|
|
|
|
void
|
|
setRecordPath(const std::string& recPath)
|
|
{
|
|
libjami::setRecordPath(recPath);
|
|
}
|
|
|
|
auto
|
|
getIsAlwaysRecording() -> decltype(libjami::getIsAlwaysRecording())
|
|
{
|
|
return libjami::getIsAlwaysRecording();
|
|
}
|
|
|
|
void
|
|
setIsAlwaysRecording(const bool& rec)
|
|
{
|
|
libjami::setIsAlwaysRecording(rec);
|
|
}
|
|
|
|
auto
|
|
getRecordPreview() -> decltype(libjami::getRecordPreview())
|
|
{
|
|
return libjami::getRecordPreview();
|
|
}
|
|
|
|
void
|
|
setRecordPreview(const bool& rec)
|
|
{
|
|
libjami::setRecordPreview(rec);
|
|
}
|
|
|
|
auto
|
|
getRecordQuality() -> decltype(libjami::getRecordQuality())
|
|
{
|
|
return libjami::getRecordQuality();
|
|
}
|
|
|
|
void
|
|
setRecordQuality(const int32_t& quality)
|
|
{
|
|
libjami::setRecordQuality(quality);
|
|
}
|
|
|
|
void
|
|
setHistoryLimit(const int32_t& days)
|
|
{
|
|
libjami::setHistoryLimit(days);
|
|
}
|
|
|
|
auto
|
|
getHistoryLimit() -> decltype(libjami::getHistoryLimit())
|
|
{
|
|
return libjami::getHistoryLimit();
|
|
}
|
|
|
|
void
|
|
setRingingTimeout(const int32_t& timeout)
|
|
{
|
|
libjami::setRingingTimeout(timeout);
|
|
}
|
|
|
|
auto
|
|
getRingingTimeout() -> decltype(libjami::getRingingTimeout())
|
|
{
|
|
return libjami::getRingingTimeout();
|
|
}
|
|
|
|
void
|
|
setAccountsOrder(const std::string& order)
|
|
{
|
|
libjami::setAccountsOrder(order);
|
|
}
|
|
|
|
auto
|
|
validateCertificate(const std::string& accountId,
|
|
const std::string& certificate)
|
|
-> decltype(libjami::validateCertificate(accountId, certificate))
|
|
{
|
|
return libjami::validateCertificate(accountId, certificate);
|
|
}
|
|
|
|
auto
|
|
validateCertificatePath(const std::string& accountId,
|
|
const std::string& certificate,
|
|
const std::string& privateKey,
|
|
const std::string& privateKeyPass,
|
|
const std::string& caList)
|
|
-> decltype(libjami::validateCertificatePath(
|
|
accountId, certificate, privateKey, privateKeyPass, caList))
|
|
{
|
|
return libjami::validateCertificatePath(accountId,
|
|
certificate,
|
|
privateKey,
|
|
privateKeyPass,
|
|
caList);
|
|
}
|
|
|
|
auto
|
|
getCertificateDetails(const std::string& accountId,
|
|
const std::string& certificate)
|
|
-> decltype(libjami::getCertificateDetails(accountId, certificate))
|
|
{
|
|
return libjami::getCertificateDetails(accountId, certificate);
|
|
}
|
|
|
|
auto
|
|
getCertificateDetailsPath(const std::string& accountId,
|
|
const std::string& certificate,
|
|
const std::string& privateKey,
|
|
const std::string& privateKeyPass)
|
|
-> decltype(libjami::getCertificateDetailsPath(
|
|
accountId, certificate, privateKey, privateKeyPass))
|
|
{
|
|
return libjami::getCertificateDetailsPath(accountId, certificate, privateKey, privateKeyPass);
|
|
}
|
|
|
|
auto
|
|
getPinnedCertificates(const std::string& accountId)
|
|
-> decltype(libjami::getPinnedCertificates(accountId))
|
|
{
|
|
return libjami::getPinnedCertificates(accountId);
|
|
}
|
|
|
|
auto
|
|
pinCertificate(const std::string& accountId,
|
|
const std::vector<uint8_t>& certificate,
|
|
const bool& local)
|
|
-> decltype(libjami::pinCertificate(accountId, certificate, local))
|
|
{
|
|
return libjami::pinCertificate(accountId, certificate, local);
|
|
}
|
|
|
|
void
|
|
pinCertificatePath(const std::string& accountId, const std::string& certPath)
|
|
{
|
|
libjami::pinCertificatePath(accountId, certPath);
|
|
}
|
|
|
|
auto
|
|
unpinCertificate(const std::string& accountId, const std::string& certId)
|
|
-> decltype(libjami::unpinCertificate(accountId, certId))
|
|
{
|
|
return libjami::unpinCertificate(accountId, certId);
|
|
}
|
|
|
|
auto
|
|
unpinCertificatePath(const std::string& accountId,
|
|
const std::string& p)
|
|
-> decltype(libjami::unpinCertificatePath(accountId, p))
|
|
{
|
|
return libjami::unpinCertificatePath(accountId, p);
|
|
}
|
|
|
|
auto
|
|
pinRemoteCertificate(const std::string& accountId,
|
|
const std::string& certId)
|
|
-> decltype(libjami::pinRemoteCertificate(accountId, certId))
|
|
{
|
|
return libjami::pinRemoteCertificate(accountId, certId);
|
|
}
|
|
|
|
auto
|
|
setCertificateStatus(const std::string& accountId,
|
|
const std::string& certId,
|
|
const std::string& status)
|
|
-> decltype(libjami::setCertificateStatus(accountId, certId, status))
|
|
{
|
|
return libjami::setCertificateStatus(accountId, certId, status);
|
|
}
|
|
|
|
auto
|
|
getCertificatesByStatus(const std::string& accountId,
|
|
const std::string& status)
|
|
-> decltype(libjami::getCertificatesByStatus(accountId, status))
|
|
{
|
|
return libjami::getCertificatesByStatus(accountId, status);
|
|
}
|
|
|
|
auto
|
|
getTrustRequests(const std::string& accountId)
|
|
-> decltype(libjami::getTrustRequests(accountId))
|
|
{
|
|
return libjami::getTrustRequests(accountId);
|
|
}
|
|
|
|
auto
|
|
acceptTrustRequest(const std::string& accountId, const std::string& from)
|
|
-> decltype(libjami::acceptTrustRequest(accountId, from))
|
|
{
|
|
return libjami::acceptTrustRequest(accountId, from);
|
|
}
|
|
|
|
auto
|
|
discardTrustRequest(const std::string& accountId, const std::string& from)
|
|
-> decltype(libjami::discardTrustRequest(accountId, from))
|
|
{
|
|
return libjami::discardTrustRequest(accountId, from);
|
|
}
|
|
|
|
void
|
|
sendTrustRequest(const std::string& accountId,
|
|
const std::string& to,
|
|
const std::vector<uint8_t>& payload)
|
|
{
|
|
libjami::sendTrustRequest(accountId, to, payload);
|
|
}
|
|
|
|
void
|
|
addContact(const std::string& accountId, const std::string& uri)
|
|
{
|
|
libjami::addContact(accountId, uri);
|
|
}
|
|
|
|
void
|
|
removeContact(const std::string& accountId,
|
|
const std::string& uri,
|
|
const bool& ban)
|
|
{
|
|
libjami::removeContact(accountId, uri, ban);
|
|
}
|
|
|
|
auto
|
|
getContactDetails(const std::string& accountId, const std::string& uri)
|
|
-> decltype(libjami::getContactDetails(accountId, uri))
|
|
{
|
|
return libjami::getContactDetails(accountId, uri);
|
|
}
|
|
|
|
auto
|
|
getContacts(const std::string& accountId)
|
|
-> decltype(libjami::getContacts(accountId))
|
|
{
|
|
return libjami::getContacts(accountId);
|
|
}
|
|
|
|
auto
|
|
getCredentials(const std::string& accountID)
|
|
-> decltype(libjami::getCredentials(accountID))
|
|
{
|
|
return libjami::getCredentials(accountID);
|
|
}
|
|
|
|
void
|
|
setCredentials(
|
|
const std::string& accountID, const std::vector<std::map<std::string, std::string>>& details)
|
|
{
|
|
libjami::setCredentials(accountID, details);
|
|
}
|
|
|
|
auto
|
|
getAddrFromInterfaceName(const std::string& interface)
|
|
-> decltype(libjami::getAddrFromInterfaceName(interface))
|
|
{
|
|
return libjami::getAddrFromInterfaceName(interface);
|
|
}
|
|
|
|
auto
|
|
getAllIpInterface() -> decltype(libjami::getAllIpInterface())
|
|
{
|
|
return libjami::getAllIpInterface();
|
|
}
|
|
|
|
auto
|
|
getAllIpInterfaceByName() -> decltype(libjami::getAllIpInterfaceByName())
|
|
{
|
|
return libjami::getAllIpInterfaceByName();
|
|
}
|
|
|
|
void
|
|
setVolume(const std::string& device, const double& value)
|
|
{
|
|
libjami::setVolume(device, value);
|
|
}
|
|
|
|
auto
|
|
getVolume(const std::string& device)
|
|
-> decltype(libjami::getVolume(device))
|
|
{
|
|
return libjami::getVolume(device);
|
|
}
|
|
|
|
void
|
|
connectivityChanged()
|
|
{
|
|
libjami::connectivityChanged();
|
|
}
|
|
|
|
void
|
|
sendFile(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& path,
|
|
const std::string& displayName,
|
|
const std::string& replyTo)
|
|
{
|
|
libjami::sendFile(accountId, conversationId, path, displayName, replyTo);
|
|
}
|
|
|
|
std::tuple<uint32_t, std::string, int64_t, int64_t>
|
|
fileTransferInfo(const std::string& accountId,
|
|
const std::string& to,
|
|
const std::string& fileId)
|
|
{
|
|
uint32_t error;
|
|
std::string path;
|
|
int64_t total;
|
|
int64_t progress;
|
|
error = (uint32_t) libjami::fileTransferInfo(accountId, to, fileId, path, total, progress);
|
|
return {error, path, total, progress};
|
|
}
|
|
|
|
bool
|
|
downloadFile(const std::string& accountId,
|
|
const std::string& conversationUri,
|
|
const std::string& interactionId,
|
|
const std::string& fileId,
|
|
const std::string& path)
|
|
{
|
|
return libjami::downloadFile(accountId, conversationUri, interactionId, fileId, path);
|
|
}
|
|
|
|
uint32_t
|
|
cancelDataTransfer(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& fileId)
|
|
{
|
|
return uint32_t(libjami::cancelDataTransfer(accountId, conversationId, fileId));
|
|
}
|
|
|
|
std::string
|
|
startConversation(const std::string& accountId)
|
|
{
|
|
return libjami::startConversation(accountId);
|
|
}
|
|
|
|
void
|
|
acceptConversationRequest(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
libjami::acceptConversationRequest(accountId, conversationId);
|
|
}
|
|
|
|
void
|
|
declineConversationRequest(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
libjami::declineConversationRequest(accountId, conversationId);
|
|
}
|
|
|
|
bool
|
|
removeConversation(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
return libjami::removeConversation(accountId, conversationId);
|
|
}
|
|
|
|
std::vector<std::string>
|
|
getConversations(const std::string& accountId)
|
|
{
|
|
return libjami::getConversations(accountId);
|
|
}
|
|
|
|
std::vector<std::map<std::string, std::string>>
|
|
getActiveCalls(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
return libjami::getActiveCalls(accountId, conversationId);
|
|
}
|
|
|
|
std::vector<std::map<std::string, std::string>>
|
|
getConversationRequests(const std::string& accountId)
|
|
{
|
|
return libjami::getConversationRequests(accountId);
|
|
}
|
|
|
|
void
|
|
updateConversationInfos(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::map<std::string, std::string>& infos)
|
|
{
|
|
libjami::updateConversationInfos(accountId, conversationId, infos);
|
|
}
|
|
|
|
std::map<std::string, std::string>
|
|
conversationInfos(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
return libjami::conversationInfos(accountId, conversationId);
|
|
}
|
|
|
|
void
|
|
setConversationPreferences(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::map<std::string, std::string>& infos)
|
|
{
|
|
libjami::setConversationPreferences(accountId, conversationId, infos);
|
|
}
|
|
|
|
std::map<std::string, std::string>
|
|
getConversationPreferences(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
return libjami::getConversationPreferences(accountId, conversationId);
|
|
}
|
|
|
|
void
|
|
addConversationMember(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& contactUri)
|
|
{
|
|
libjami::addConversationMember(accountId, conversationId, contactUri);
|
|
}
|
|
|
|
void
|
|
removeConversationMember(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& contactUri)
|
|
{
|
|
libjami::removeConversationMember(accountId, conversationId, contactUri);
|
|
}
|
|
|
|
std::vector<std::map<std::string, std::string>>
|
|
getConversationMembers(const std::string& accountId,
|
|
const std::string& conversationId)
|
|
{
|
|
return libjami::getConversationMembers(accountId, conversationId);
|
|
}
|
|
|
|
void
|
|
sendMessage(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& message,
|
|
const std::string& replyTo,
|
|
const int32_t& flag)
|
|
{
|
|
libjami::sendMessage(accountId, conversationId, message, replyTo, flag);
|
|
}
|
|
|
|
uint32_t
|
|
loadConversationMessages(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& fromMessage,
|
|
const uint32_t& n)
|
|
{
|
|
return libjami::loadConversationMessages(accountId, conversationId, fromMessage, n);
|
|
}
|
|
|
|
uint32_t
|
|
loadConversationUntil(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& fromMessage,
|
|
const std::string& to)
|
|
{
|
|
return libjami::loadConversationUntil(accountId, conversationId, fromMessage, to);
|
|
}
|
|
|
|
uint32_t
|
|
countInteractions(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& toId,
|
|
const std::string& fromId,
|
|
const std::string& authorUri)
|
|
{
|
|
return libjami::countInteractions(accountId, conversationId, toId, fromId, authorUri);
|
|
}
|
|
|
|
uint32_t
|
|
searchConversation(const std::string& accountId,
|
|
const std::string& conversationId,
|
|
const std::string& author,
|
|
const std::string& lastId,
|
|
const std::string& regexSearch,
|
|
const std::string& type,
|
|
const int64_t& after,
|
|
const int64_t& before,
|
|
const uint32_t& maxResult,
|
|
const int32_t& flag)
|
|
{
|
|
return libjami::searchConversation(accountId,
|
|
conversationId,
|
|
author,
|
|
lastId,
|
|
regexSearch,
|
|
type,
|
|
after,
|
|
before,
|
|
maxResult,
|
|
flag);
|
|
}
|
|
|
|
bool
|
|
isAudioMeterActive(const std::string& id)
|
|
{
|
|
return libjami::isAudioMeterActive(id);
|
|
}
|
|
|
|
void
|
|
setAudioMeterState(const std::string& id, const bool& state)
|
|
{
|
|
return libjami::setAudioMeterState(id, state);
|
|
}
|
|
|
|
void
|
|
setDefaultModerator(const std::string& accountID,
|
|
const std::string& peerURI,
|
|
const bool& state)
|
|
{
|
|
libjami::setDefaultModerator(accountID, peerURI, state);
|
|
}
|
|
|
|
auto
|
|
getDefaultModerators(const std::string& accountID)
|
|
-> decltype(libjami::getDefaultModerators(accountID))
|
|
{
|
|
return libjami::getDefaultModerators(accountID);
|
|
}
|
|
|
|
void
|
|
enableLocalModerators(const std::string& accountID,
|
|
const bool& isModEnabled)
|
|
{
|
|
return libjami::enableLocalModerators(accountID, isModEnabled);
|
|
}
|
|
|
|
bool
|
|
isLocalModeratorsEnabled(const std::string& accountID)
|
|
{
|
|
return libjami::isLocalModeratorsEnabled(accountID);
|
|
}
|
|
|
|
void
|
|
setAllModerators(const std::string& accountID, const bool& allModerators)
|
|
{
|
|
return libjami::setAllModerators(accountID, allModerators);
|
|
}
|
|
|
|
bool
|
|
isAllModerators(const std::string& accountID)
|
|
{
|
|
return libjami::isAllModerators(accountID);
|
|
}
|
|
|
|
private:
|
|
|
|
void
|
|
registerSignalHandlers()
|
|
{
|
|
using namespace std::placeholders;
|
|
|
|
using libjami::exportable_serialized_callback;
|
|
using libjami::ConfigurationSignal;
|
|
using libjami::AudioSignal;
|
|
using libjami::DataTransferSignal;
|
|
using libjami::ConversationSignal;
|
|
using SharedCallback = std::shared_ptr<libjami::CallbackWrapperBase>;
|
|
|
|
// Configuration event handlers
|
|
const std::map<std::string, SharedCallback> configEvHandlers = {
|
|
exportable_serialized_callback<ConfigurationSignal::VolumeChanged>(
|
|
std::bind(&DBusConfigurationManager::emitVolumeChanged, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::AccountsChanged>(
|
|
std::bind(&DBusConfigurationManager::emitAccountsChanged, this)),
|
|
exportable_serialized_callback<ConfigurationSignal::AccountDetailsChanged>(
|
|
std::bind(&DBusConfigurationManager::emitAccountDetailsChanged, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::StunStatusFailed>(
|
|
std::bind(&DBusConfigurationManager::emitStunStatusFailure, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::RegistrationStateChanged>(
|
|
std::bind(&DBusConfigurationManager::emitRegistrationStateChanged, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConfigurationSignal::VolatileDetailsChanged>(
|
|
std::bind(&DBusConfigurationManager::emitVolatileAccountDetailsChanged, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::Error>(
|
|
std::bind(&DBusConfigurationManager::emitErrorAlert, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::IncomingAccountMessage>(
|
|
std::bind(&DBusConfigurationManager::emitIncomingAccountMessage, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConfigurationSignal::AccountMessageStatusChanged>(
|
|
std::bind(&DBusConfigurationManager::emitAccountMessageStatusChanged, this, _1, _2, _3, _4, _5)),
|
|
exportable_serialized_callback<ConfigurationSignal::ProfileReceived>(
|
|
std::bind(&DBusConfigurationManager::emitProfileReceived, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::ActiveCallsChanged>(
|
|
std::bind(&DBusConfigurationManager::emitActiveCallsChanged, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::ComposingStatusChanged>(
|
|
std::bind(&DBusConfigurationManager::emitComposingStatusChanged, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConfigurationSignal::IncomingTrustRequest>(
|
|
std::bind(&DBusConfigurationManager::emitIncomingTrustRequest, this, _1, _2, _3, _4, _5)),
|
|
exportable_serialized_callback<ConfigurationSignal::ContactAdded>(
|
|
std::bind(&DBusConfigurationManager::emitContactAdded, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::ContactRemoved>(
|
|
std::bind(&DBusConfigurationManager::emitContactRemoved, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::ExportOnRingEnded>(
|
|
std::bind(&DBusConfigurationManager::emitExportOnRingEnded, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::KnownDevicesChanged>(
|
|
std::bind(&DBusConfigurationManager::emitKnownDevicesChanged, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::NameRegistrationEnded>(
|
|
std::bind(&DBusConfigurationManager::emitNameRegistrationEnded, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::UserSearchEnded>(
|
|
std::bind(&DBusConfigurationManager::emitUserSearchEnded, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConfigurationSignal::RegisteredNameFound>(
|
|
std::bind(&DBusConfigurationManager::emitRegisteredNameFound, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConfigurationSignal::DeviceRevocationEnded>(
|
|
std::bind(&DBusConfigurationManager::emitDeviceRevocationEnded, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::AccountProfileReceived>(
|
|
std::bind(&DBusConfigurationManager::emitAccountProfileReceived, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::CertificatePinned>(
|
|
std::bind(&DBusConfigurationManager::emitCertificatePinned, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::CertificatePathPinned>(
|
|
std::bind(&DBusConfigurationManager::emitCertificatePathPinned, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::CertificateExpired>(
|
|
std::bind(&DBusConfigurationManager::emitCertificateExpired, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::CertificateStateChanged>(
|
|
std::bind(&DBusConfigurationManager::emitCertificateStateChanged, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConfigurationSignal::MediaParametersChanged>(
|
|
std::bind(&DBusConfigurationManager::emitMediaParametersChanged, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::MigrationEnded>(
|
|
std::bind(&DBusConfigurationManager::emitMigrationEnded, this, _1, _2)),
|
|
exportable_serialized_callback<ConfigurationSignal::HardwareDecodingChanged>(
|
|
std::bind(&DBusConfigurationManager::emitHardwareDecodingChanged, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::HardwareEncodingChanged>(
|
|
std::bind(&DBusConfigurationManager::emitHardwareEncodingChanged, this, _1)),
|
|
exportable_serialized_callback<ConfigurationSignal::MessageSend>(
|
|
std::bind(&DBusConfigurationManager::emitMessageSend, this, _1)),
|
|
};
|
|
|
|
// Audio event handlers
|
|
const std::map<std::string, SharedCallback> audioEvHandlers = {
|
|
exportable_serialized_callback<AudioSignal::DeviceEvent>(
|
|
std::bind(&DBusConfigurationManager::emitAudioDeviceEvent, this)),
|
|
exportable_serialized_callback<AudioSignal::AudioMeter>(
|
|
std::bind(&DBusConfigurationManager::emitAudioMeter, this, _1, _2)),
|
|
};
|
|
|
|
const std::map<std::string, SharedCallback> dataXferEvHandlers = {
|
|
exportable_serialized_callback<DataTransferSignal::DataTransferEvent>(
|
|
std::bind(&DBusConfigurationManager::emitDataTransferEvent, this, _1, _2, _3, _4, _5)),
|
|
};
|
|
|
|
const std::map<std::string, SharedCallback> convEvHandlers = {
|
|
exportable_serialized_callback<ConversationSignal::ConversationLoaded>(
|
|
std::bind(&DBusConfigurationManager::emitConversationLoaded, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConversationSignal::MessagesFound>(
|
|
std::bind(&DBusConfigurationManager::emitMessagesFound, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConversationSignal::MessageReceived>(
|
|
std::bind(&DBusConfigurationManager::emitMessageReceived, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationProfileUpdated>(
|
|
std::bind(&DBusConfigurationManager::emitConversationProfileUpdated, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationRequestReceived>(
|
|
std::bind(&DBusConfigurationManager::emitConversationRequestReceived, this, _1, _2, _3)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationRequestDeclined>(
|
|
std::bind(&DBusConfigurationManager::emitConversationRequestDeclined, this, _1, _2)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationReady>(
|
|
std::bind(&DBusConfigurationManager::emitConversationReady, this, _1, _2)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationRemoved>(
|
|
std::bind(&DBusConfigurationManager::emitConversationRemoved, this, _1, _2)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationMemberEvent>(
|
|
std::bind(&DBusConfigurationManager::emitConversationMemberEvent, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConversationSignal::OnConversationError>(
|
|
std::bind(&DBusConfigurationManager::emitOnConversationError, this, _1, _2, _3, _4)),
|
|
exportable_serialized_callback<ConversationSignal::ConversationPreferencesUpdated>(
|
|
std::bind(&DBusConfigurationManager::emitConversationPreferencesUpdated, this, _1, _2, _3)),
|
|
};
|
|
|
|
libjami::registerSignalHandlers(configEvHandlers);
|
|
libjami::registerSignalHandlers(audioEvHandlers);
|
|
libjami::registerSignalHandlers(dataXferEvHandlers);
|
|
libjami::registerSignalHandlers(convEvHandlers);
|
|
}
|
|
};
|