From d54a84ec0bbf65a3719f6988e13c1ff1a3ad54b6 Mon Sep 17 00:00:00 2001 From: Olivier Dion Date: Thu, 27 Oct 2022 16:00:41 -0400 Subject: [PATCH] Replace DRing for libjami It's not possible to replace the DRing namespace for jami because of conflicts with namespaces and classes defined under the jami namespace. Thus, use libjami as the namespace. Script to reproduce: rg -l DRing | sort | uniq | awk '$0 !~ /NEWS/' | xargs sed -i -e 's|DRing|libjami|g' rg -l DRING_ | sort | uniq | xargs sed -i -e 's|DRING_|LIBJAMI_|g' sed -i -e 's|dring|jami|g' src/jami/CMakeLists.txt sed -i -e 's|dring|jami|g' src/jami/def.h Change-Id: I80e8c8b58a7586527a016bbef850bab07869c473 --- README | 2 +- .../cx.ring.Ring.ConfigurationManager.xml | 2 +- bin/dbus/dbuscallmanager.cpp | 174 ++-- bin/dbus/dbuscallmanager.h | 4 +- bin/dbus/dbusclient.cpp | 44 +- bin/dbus/dbusclient.h | 2 +- bin/dbus/dbusconfigurationmanager.cpp | 416 ++++----- bin/dbus/dbusconfigurationmanager.h | 4 +- bin/dbus/dbusinstance.h | 2 +- bin/dbus/dbuspluginmanagerinterface.cpp | 56 +- bin/dbus/dbuspluginmanagerinterface.h | 2 +- bin/dbus/dbuspresencemanager.cpp | 12 +- bin/dbus/dbuspresencemanager.h | 2 +- bin/dbus/dbusvideomanager.cpp | 50 +- bin/dbus/dbusvideomanager.h | 2 +- bin/dbus/main.cpp | 8 +- bin/jni/callmanager.i | 4 +- bin/jni/configurationmanager.i | 6 +- bin/jni/conversation.i | 2 +- bin/jni/datatransfer.i | 24 +- bin/jni/jni_interface.i | 22 +- bin/jni/managerimpl.i | 2 +- bin/jni/plugin_manager_interface.i | 2 +- bin/jni/presencemanager.i | 2 +- bin/jni/videomanager.i | 28 +- bin/main.cpp | 8 +- bin/nodejs/callmanager.i | 4 +- bin/nodejs/configurationmanager.i | 2 +- bin/nodejs/conversation.i | 2 +- bin/nodejs/managerimpl.i | 2 +- bin/nodejs/nodejs_interface.i | 14 +- bin/nodejs/presencemanager.i | 2 +- bin/nodejs/videomanager.i | 4 +- bin/osxmain.cpp | 18 +- bin/winmain.cpp | 22 +- configure.ac | 4 +- globals.mk | 4 +- meson.build | 2 +- src/account.cpp | 16 +- src/account.h | 6 +- src/archiver.cpp | 18 +- src/buildinfo.cpp | 4 +- src/call.cpp | 32 +- src/call.h | 12 +- src/call_factory.cpp | 2 +- src/call_factory.h | 2 +- src/client/callmanager.cpp | 14 +- src/client/configurationmanager.cpp | 8 +- src/client/conversation_interface.cpp | 4 +- src/client/datatransfer.cpp | 32 +- src/client/plugin_manager_interface.cpp | 4 +- src/client/presencemanager.cpp | 16 +- src/client/ring_signal.cpp | 186 ++-- src/client/ring_signal.h | 8 +- src/client/videomanager.cpp | 20 +- src/conference.cpp | 34 +- src/conference.h | 6 +- src/data_transfer.cpp | 190 ++-- src/data_transfer.h | 30 +- src/fileutils.cpp | 16 +- src/fileutils.h | 2 +- src/ftp_server.cpp | 6 +- src/ftp_server.h | 10 +- src/im/message_engine.cpp | 20 +- src/ip_utils.cpp | 2 +- src/jami/CMakeLists.txt | 6 +- src/jami/account_const.h | 10 +- src/jami/call_const.h | 8 +- src/jami/callmanager_interface.h | 176 ++-- src/jami/configurationmanager_interface.h | 312 +++---- src/jami/conversation_interface.h | 74 +- src/jami/datatransfer_interface.h | 38 +- src/jami/def.h | 38 +- src/jami/jami.h | 38 +- src/jami/media_const.h | 8 +- src/jami/plugin_manager_interface.h | 54 +- src/jami/presence_const.h | 8 +- src/jami/presencemanager_interface.h | 32 +- src/jami/security_const.h | 8 +- src/jami/videomanager_interface.h | 104 +-- src/jamidht/account_manager.cpp | 4 +- src/jamidht/accountarchive.cpp | 16 +- src/jamidht/archive_account_manager.cpp | 2 +- src/jamidht/connectionmanager.cpp | 2 +- src/jamidht/contact_list.cpp | 16 +- src/jamidht/conversation.cpp | 24 +- src/jamidht/conversation_module.cpp | 42 +- src/jamidht/conversationrepository.cpp | 46 +- src/jamidht/conversationrepository.h | 6 +- src/jamidht/gitserver.h | 2 +- src/jamidht/jamiaccount.cpp | 216 ++--- src/jamidht/jamiaccount.h | 16 +- src/jamidht/multiplexed_socket.cpp | 4 +- src/jamidht/multiplexed_socket.h | 4 +- src/jamidht/p2p.cpp | 42 +- src/jamidht/p2p.h | 10 +- src/jamidht/server_account_manager.cpp | 2 +- src/logger.cpp | 4 +- src/logger.h | 6 +- src/manager.cpp | 78 +- src/manager.h | 18 +- src/media/audio/alsa/alsalayer.cpp | 6 +- src/media/audio/audio_input.cpp | 4 +- src/media/audio/audiolayer.cpp | 2 +- src/media/audio/opensl/opensllayer.cpp | 2 +- src/media/audio/ringbuffer.cpp | 2 +- src/media/audio/sound/audiofile.cpp | 2 +- src/media/audio/tonecontrol.cpp | 6 +- src/media/media_attribute.cpp | 50 +- src/media/media_attribute.h | 14 +- src/media/media_buffer.h | 6 +- src/media/media_codec.cpp | 64 +- src/media/media_decoder.cpp | 2 +- src/media/media_decoder.h | 6 +- src/media/media_encoder.cpp | 2 +- src/media/media_filter.cpp | 2 +- src/media/media_player.cpp | 4 +- src/media/media_recorder.cpp | 2 +- .../video/androidvideo/video_device_impl.cpp | 4 +- .../video/iosvideo/video_device_impl.cpp | 2 +- src/media/video/sinkclient.cpp | 6 +- src/media/video/sinkclient.h | 4 +- .../video/uwpvideo/video_device_impl.cpp | 2 +- src/media/video/video_base.h | 8 +- src/media/video/video_device.h | 4 +- src/media/video/video_device_monitor.cpp | 10 +- src/media/video/video_device_monitor.h | 2 +- src/media/video/video_input.cpp | 12 +- src/media/video/video_rtp_session.cpp | 4 +- src/peer_connection.h | 2 +- src/plugin/jamipluginmanager.cpp | 4 +- src/plugin/webviewservicesmanager.cpp | 2 +- src/preferences.cpp | 6 +- src/preferences.h | 4 +- src/ring_api.cpp | 12 +- src/security/certstore.cpp | 20 +- src/security/tlsvalidator.cpp | 100 +-- src/sip/pres_sub_client.cpp | 6 +- src/sip/pres_sub_server.cpp | 2 +- src/sip/sipaccount.cpp | 22 +- src/sip/sipaccount.h | 4 +- src/sip/sipaccountbase.cpp | 6 +- src/sip/sipaccountbase.h | 6 +- src/sip/sipcall.cpp | 56 +- src/sip/sipcall.h | 14 +- src/sip/sippresence.cpp | 6 +- src/sip/sipvoiplink.cpp | 2 +- src/smartools.cpp | 2 +- test/agent/src/bindings/account.h | 26 +- test/agent/src/bindings/call.h | 14 +- test/agent/src/bindings/conversation.h | 10 +- test/agent/src/bindings/jami.h | 14 +- test/agent/src/bindings/signal.cpp | 184 ++-- test/agent/src/main.cpp | 2 +- test/fuzzing/lib/utils.cpp | 22 +- .../fuzzing/scenarios/classic-alice-and-bob.h | 12 +- test/sip/sip.cpp | 6 +- .../account_archive/account_archive.cpp | 42 +- test/unitTest/account_archive/migration.cpp | 56 +- .../account_factory/testAccount_factory.cpp | 12 +- test/unitTest/call/call.cpp | 58 +- test/unitTest/call/conference.cpp | 224 ++--- test/unitTest/call/recorder.cpp | 112 +-- test/unitTest/certstore.cpp | 4 +- test/unitTest/common.cpp | 22 +- .../connectionManager/connectionManager.cpp | 8 +- test/unitTest/conversation/compability.cpp | 50 +- test/unitTest/conversation/conversation.cpp | 844 +++++++++--------- .../conversation/conversationMembersEvent.cpp | 644 ++++++------- .../conversation/conversationRequest.cpp | 252 +++--- .../conversation/conversationcommon.cpp | 2 +- .../conversationRepository.cpp | 8 +- test/unitTest/fileTransfer/fileTransfer.cpp | 330 +++---- test/unitTest/ice/ice.cpp | 8 +- test/unitTest/ice/ice_media_cand_exchange.cpp | 92 +- test/unitTest/ice/ice_sdp_parser.cpp | 64 +- test/unitTest/media/audio/test_resampler.cpp | 12 +- test/unitTest/media/test_media_decoder.cpp | 4 +- test/unitTest/media/test_media_encoder.cpp | 4 +- test/unitTest/media/test_media_filter.cpp | 4 +- test/unitTest/media/test_media_frame.cpp | 12 +- test/unitTest/media/video/testVideo_input.cpp | 12 +- .../media/video/test_video_scaler.cpp | 10 +- .../media_negotiation/auto_answer.cpp | 100 +-- .../media_negotiation/hold_resume.cpp | 86 +- .../media_negotiation/media_negotiation.cpp | 112 +-- test/unitTest/plugins/plugins.cpp | 66 +- test/unitTest/revoke/revoke.cpp | 24 +- test/unitTest/sip_account/sip_basic_calls.cpp | 154 ++-- test/unitTest/sip_account/sip_srtp.cpp | 72 +- test/unitTest/syncHistory/syncHistory.cpp | 332 +++---- tools/jamictrl/controller.py | 54 +- tools/jamictrl/errorsDring.py | 8 +- tools/jamictrl/jami_test.py | 10 +- tools/jamictrl/jamictrl.py | 10 +- tools/jamictrl/sendfile.py | 4 +- tools/jamictrl/swarm.py | 4 +- tools/jamictrl/test_jami_dbus_interface.py | 2 +- tools/jamictrl/tester.py | 2 +- tools/jamictrl/toggle_video_preview.py | 2 +- 200 files changed, 3934 insertions(+), 3934 deletions(-) diff --git a/README b/README index d84c47ef2..fd825b6d6 100644 --- a/README +++ b/README @@ -44,7 +44,7 @@ the Contributing section for more information. Short description of content of source tree ------------------------------------------- -- src/ is the core of DRing. +- src/ is the core of libjami. - bin/ contains applications main code. - bin/dbus, the D-Bus XML interfaces, and C++ bindings diff --git a/bin/dbus/cx.ring.Ring.ConfigurationManager.xml b/bin/dbus/cx.ring.Ring.ConfigurationManager.xml index 56c3e8137..6a0c4289e 100644 --- a/bin/dbus/cx.ring.Ring.ConfigurationManager.xml +++ b/bin/dbus/cx.ring.Ring.ConfigurationManager.xml @@ -1910,7 +1910,7 @@ - A DRing::DataTransferEventCode code + A libjami::DataTransferEventCode code diff --git a/bin/dbus/dbuscallmanager.cpp b/bin/dbus/dbuscallmanager.cpp index bdfa48006..7b77bd422 100644 --- a/bin/dbus/dbuscallmanager.cpp +++ b/bin/dbus/dbuscallmanager.cpp @@ -26,49 +26,49 @@ DBusCallManager::DBusCallManager(DBus::Connection& connection) auto DBusCallManager::placeCall(const std::string& accountId, const std::string& to) - -> decltype(DRing::placeCall(accountId, to)) + -> decltype(libjami::placeCall(accountId, to)) { - return DRing::placeCall(accountId, to); + return libjami::placeCall(accountId, to); } auto DBusCallManager::placeCallWithMedia(const std::string& accountId, const std::string& to, const std::vector>& mediaList) - -> decltype(DRing::placeCallWithMedia(accountId, to, mediaList)) + -> decltype(libjami::placeCallWithMedia(accountId, to, mediaList)) { - return DRing::placeCallWithMedia(accountId, to, mediaList); + return libjami::placeCallWithMedia(accountId, to, mediaList); } auto DBusCallManager::requestMediaChange(const std::string& accountId, const std::string& callId, const std::vector>& mediaList) - -> decltype(DRing::requestMediaChange(accountId, callId, mediaList)) + -> decltype(libjami::requestMediaChange(accountId, callId, mediaList)) { - return DRing::requestMediaChange(accountId, callId, mediaList); + return libjami::requestMediaChange(accountId, callId, mediaList); } auto DBusCallManager::refuse(const std::string& accountId, const std::string& callId) - -> decltype(DRing::refuse(accountId, callId)) + -> decltype(libjami::refuse(accountId, callId)) { - return DRing::refuse(accountId, callId); + return libjami::refuse(accountId, callId); } auto DBusCallManager::accept(const std::string& accountId, const std::string& callId) - -> decltype(DRing::accept(accountId, callId)) + -> decltype(libjami::accept(accountId, callId)) { - return DRing::accept(accountId, callId); + return libjami::accept(accountId, callId); } auto DBusCallManager::acceptWithMedia(const std::string& accountId, const std::string& callId, const std::vector>& mediaList) - -> decltype(DRing::acceptWithMedia(accountId, callId, mediaList)) + -> decltype(libjami::acceptWithMedia(accountId, callId, mediaList)) { - return DRing::acceptWithMedia(accountId, callId, mediaList); + return libjami::acceptWithMedia(accountId, callId, mediaList); } auto @@ -76,30 +76,30 @@ DBusCallManager::answerMediaChangeRequest( const std::string& accountId, const std::string& callId, const std::vector>& mediaList) - -> decltype(DRing::answerMediaChangeRequest(accountId, callId, mediaList)) + -> decltype(libjami::answerMediaChangeRequest(accountId, callId, mediaList)) { - return DRing::answerMediaChangeRequest(accountId, callId, mediaList); + return libjami::answerMediaChangeRequest(accountId, callId, mediaList); } auto DBusCallManager::hangUp(const std::string& accountId, const std::string& callId) - -> decltype(DRing::hangUp(accountId, callId)) + -> decltype(libjami::hangUp(accountId, callId)) { - return DRing::hangUp(accountId, callId); + return libjami::hangUp(accountId, callId); } auto DBusCallManager::hold(const std::string& accountId, const std::string& callId) - -> decltype(DRing::hold(accountId, callId)) + -> decltype(libjami::hold(accountId, callId)) { - return DRing::hold(accountId, callId); + return libjami::hold(accountId, callId); } auto DBusCallManager::unhold(const std::string& accountId, const std::string& callId) - -> decltype(DRing::unhold(accountId, callId)) + -> decltype(libjami::unhold(accountId, callId)) { - return DRing::unhold(accountId, callId); + return libjami::unhold(accountId, callId); } auto @@ -107,46 +107,46 @@ DBusCallManager::muteLocalMedia(const std::string& accountId, const std::string& callId, const std::string& mediaType, const bool& mute) - -> decltype(DRing::muteLocalMedia(accountId, callId, mediaType, mute)) + -> decltype(libjami::muteLocalMedia(accountId, callId, mediaType, mute)) { - return DRing::muteLocalMedia(accountId, callId, mediaType, mute); + return libjami::muteLocalMedia(accountId, callId, mediaType, mute); } auto DBusCallManager::transfer(const std::string& accountId, const std::string& callId, - const std::string& to) -> decltype(DRing::transfer(accountId, callId, to)) + const std::string& to) -> decltype(libjami::transfer(accountId, callId, to)) { - return DRing::transfer(accountId, callId, to); + return libjami::transfer(accountId, callId, to); } auto DBusCallManager::attendedTransfer(const std::string& accountId, const std::string& callId, const std::string& targetId) - -> decltype(DRing::attendedTransfer(accountId, callId, targetId)) + -> decltype(libjami::attendedTransfer(accountId, callId, targetId)) { - return DRing::attendedTransfer(accountId, callId, targetId); + return libjami::attendedTransfer(accountId, callId, targetId); } auto DBusCallManager::getCallDetails(const std::string& accountId, const std::string& callId) - -> decltype(DRing::getCallDetails(accountId, callId)) + -> decltype(libjami::getCallDetails(accountId, callId)) { - return DRing::getCallDetails(accountId, callId); + return libjami::getCallDetails(accountId, callId); } auto DBusCallManager::getCallList(const std::string& accountId) - -> decltype(DRing::getCallList(accountId)) + -> decltype(libjami::getCallList(accountId)) { - return DRing::getCallList(accountId); + return libjami::getCallList(accountId); } std::vector> DBusCallManager::getConferenceInfos(const std::string& accountId, const std::string& confId) { - return DRing::getConferenceInfos(accountId, confId); + return libjami::getConferenceInfos(accountId, confId); } auto @@ -154,16 +154,16 @@ DBusCallManager::joinParticipant(const std::string& accountId, const std::string& sel_callId, const std::string& account2Id, const std::string& drag_callId) - -> decltype(DRing::joinParticipant(accountId, sel_callId, account2Id, drag_callId)) + -> decltype(libjami::joinParticipant(accountId, sel_callId, account2Id, drag_callId)) { - return DRing::joinParticipant(accountId, sel_callId, account2Id, drag_callId); + return libjami::joinParticipant(accountId, sel_callId, account2Id, drag_callId); } void DBusCallManager::createConfFromParticipantList(const std::string& accountId, const std::vector& participants) { - DRing::createConfFromParticipantList(accountId, participants); + libjami::createConfFromParticipantList(accountId, participants); } void @@ -171,7 +171,7 @@ DBusCallManager::setConferenceLayout(const std::string& accountId, const std::string& confId, const uint32_t& layout) { - DRing::setConferenceLayout(accountId, confId, layout); + libjami::setConferenceLayout(accountId, confId, layout); } void @@ -179,7 +179,7 @@ DBusCallManager::setActiveParticipant(const std::string& accountId, const std::string& confId, const std::string& callId) { - DRing::setActiveParticipant(accountId, confId, callId); + libjami::setActiveParticipant(accountId, confId, callId); } void @@ -190,7 +190,7 @@ DBusCallManager::muteStream(const std::string& accountId, const std::string& streamId, const bool& state) { - DRing::muteStream(accountId, confId, accountUri, deviceId, streamId, state); + libjami::muteStream(accountId, confId, accountUri, deviceId, streamId, state); } void @@ -201,7 +201,7 @@ DBusCallManager::setActiveStream(const std::string& accountId, const std::string& streamId, const bool& state) { - DRing::setActiveStream(accountId, confId, accountUri, deviceId, streamId, state); + libjami::setActiveStream(accountId, confId, accountUri, deviceId, streamId, state); } void @@ -211,14 +211,14 @@ DBusCallManager::raiseHand(const std::string& accountId, const std::string& deviceId, const bool& state) { - DRing::raiseHand(accountId, confId, accountUri, deviceId, state); + libjami::raiseHand(accountId, confId, accountUri, deviceId, state); } auto DBusCallManager::isConferenceParticipant(const std::string& accountId, const std::string& call_id) - -> decltype(DRing::isConferenceParticipant(accountId, call_id)) + -> decltype(libjami::isConferenceParticipant(accountId, call_id)) { - return DRing::isConferenceParticipant(accountId, call_id); + return libjami::isConferenceParticipant(accountId, call_id); } auto @@ -226,29 +226,29 @@ DBusCallManager::addParticipant(const std::string& accountId, const std::string& callId, const std::string& account2Id, const std::string& confId) - -> decltype(DRing::addParticipant(accountId, callId, account2Id, confId)) + -> decltype(libjami::addParticipant(accountId, callId, account2Id, confId)) { - return DRing::addParticipant(accountId, callId, account2Id, confId); + return libjami::addParticipant(accountId, callId, account2Id, confId); } auto DBusCallManager::addMainParticipant(const std::string& accountId, const std::string& confId) - -> decltype(DRing::addMainParticipant(accountId, confId)) + -> decltype(libjami::addMainParticipant(accountId, confId)) { - return DRing::addMainParticipant(accountId, confId); + return libjami::addMainParticipant(accountId, confId); } auto -DBusCallManager::detachLocalParticipant() -> decltype(DRing::detachLocalParticipant()) +DBusCallManager::detachLocalParticipant() -> decltype(libjami::detachLocalParticipant()) { - return DRing::detachLocalParticipant(); + return libjami::detachLocalParticipant(); } auto DBusCallManager::detachParticipant(const std::string& accountId, const std::string& callId) - -> decltype(DRing::detachParticipant(accountId, callId)) + -> decltype(libjami::detachParticipant(accountId, callId)) { - return DRing::detachParticipant(accountId, callId); + return libjami::detachParticipant(accountId, callId); } auto @@ -256,104 +256,104 @@ DBusCallManager::joinConference(const std::string& accountId, const std::string& sel_confId, const std::string& account2Id, const std::string& drag_confId) - -> decltype(DRing::joinConference(accountId, sel_confId, account2Id, drag_confId)) + -> decltype(libjami::joinConference(accountId, sel_confId, account2Id, drag_confId)) { - return DRing::joinConference(accountId, sel_confId, account2Id, drag_confId); + return libjami::joinConference(accountId, sel_confId, account2Id, drag_confId); } auto DBusCallManager::hangUpConference(const std::string& accountId, const std::string& confId) - -> decltype(DRing::hangUpConference(accountId, confId)) + -> decltype(libjami::hangUpConference(accountId, confId)) { - return DRing::hangUpConference(accountId, confId); + return libjami::hangUpConference(accountId, confId); } auto DBusCallManager::holdConference(const std::string& accountId, const std::string& confId) - -> decltype(DRing::holdConference(accountId, confId)) + -> decltype(libjami::holdConference(accountId, confId)) { - return DRing::holdConference(accountId, confId); + return libjami::holdConference(accountId, confId); } auto DBusCallManager::unholdConference(const std::string& accountId, const std::string& confId) - -> decltype(DRing::unholdConference(accountId, confId)) + -> decltype(libjami::unholdConference(accountId, confId)) { - return DRing::unholdConference(accountId, confId); + return libjami::unholdConference(accountId, confId); } auto DBusCallManager::getConferenceList(const std::string& accountId) - -> decltype(DRing::getConferenceList(accountId)) + -> decltype(libjami::getConferenceList(accountId)) { - return DRing::getConferenceList(accountId); + return libjami::getConferenceList(accountId); } auto DBusCallManager::getParticipantList(const std::string& accountId, const std::string& confId) - -> decltype(DRing::getParticipantList(accountId, confId)) + -> decltype(libjami::getParticipantList(accountId, confId)) { - return DRing::getParticipantList(accountId, confId); + return libjami::getParticipantList(accountId, confId); } auto DBusCallManager::getConferenceId(const std::string& accountId, const std::string& callId) - -> decltype(DRing::getConferenceId(accountId, callId)) + -> decltype(libjami::getConferenceId(accountId, callId)) { - return DRing::getConferenceId(accountId, callId); + return libjami::getConferenceId(accountId, callId); } auto DBusCallManager::getConferenceDetails(const std::string& accountId, const std::string& callId) - -> decltype(DRing::getConferenceDetails(accountId, callId)) + -> decltype(libjami::getConferenceDetails(accountId, callId)) { - return DRing::getConferenceDetails(accountId, callId); + return libjami::getConferenceDetails(accountId, callId); } auto DBusCallManager::currentMediaList(const std::string& accountId, const std::string& callId) - -> decltype(DRing::currentMediaList(accountId, callId)) + -> decltype(libjami::currentMediaList(accountId, callId)) { - return DRing::currentMediaList(accountId, callId); + return libjami::currentMediaList(accountId, callId); } auto DBusCallManager::startRecordedFilePlayback(const std::string& filepath) - -> decltype(DRing::startRecordedFilePlayback(filepath)) + -> decltype(libjami::startRecordedFilePlayback(filepath)) { - return DRing::startRecordedFilePlayback(filepath); + return libjami::startRecordedFilePlayback(filepath); } void DBusCallManager::stopRecordedFilePlayback() { - DRing::stopRecordedFilePlayback(); + libjami::stopRecordedFilePlayback(); } auto DBusCallManager::toggleRecording(const std::string& accountId, const std::string& callId) - -> decltype(DRing::toggleRecording(accountId, callId)) + -> decltype(libjami::toggleRecording(accountId, callId)) { - return DRing::toggleRecording(accountId, callId); + return libjami::toggleRecording(accountId, callId); } void DBusCallManager::setRecording(const std::string& accountId, const std::string& callId) { - DRing::setRecording(accountId, callId); + libjami::setRecording(accountId, callId); } void DBusCallManager::recordPlaybackSeek(const double& value) { - DRing::recordPlaybackSeek(value); + libjami::recordPlaybackSeek(value); } auto DBusCallManager::getIsRecording(const std::string& accountId, const std::string& callId) - -> decltype(DRing::getIsRecording(accountId, callId)) + -> decltype(libjami::getIsRecording(accountId, callId)) { - return DRing::getIsRecording(accountId, callId); + return libjami::getIsRecording(accountId, callId); } bool @@ -361,7 +361,7 @@ DBusCallManager::switchInput(const std::string& accountId, const std::string& callId, const std::string& input) { - return DRing::switchInput(accountId, callId, input); + return libjami::switchInput(accountId, callId, input); } bool @@ -369,19 +369,19 @@ DBusCallManager::switchSecondaryInput(const std::string& accountId, const std::string& conferenceId, const std::string& input) { - return DRing::switchSecondaryInput(accountId, conferenceId, input); + return libjami::switchSecondaryInput(accountId, conferenceId, input); } void DBusCallManager::playDTMF(const std::string& key) { - DRing::playDTMF(key); + libjami::playDTMF(key); } void DBusCallManager::startTone(const int32_t& start, const int32_t& type) { - DRing::startTone(start, type); + libjami::startTone(start, type); } void @@ -390,19 +390,19 @@ DBusCallManager::sendTextMessage(const std::string& accountId, const std::map& messages, const bool& isMixed) { - DRing::sendTextMessage(accountId, callId, messages, "Me", isMixed); + libjami::sendTextMessage(accountId, callId, messages, "Me", isMixed); } void DBusCallManager::startSmartInfo(const uint32_t& refreshTimeMs) { - DRing::startSmartInfo(refreshTimeMs); + libjami::startSmartInfo(refreshTimeMs); } void DBusCallManager::stopSmartInfo() { - DRing::stopSmartInfo(); + libjami::stopSmartInfo(); } void @@ -411,7 +411,7 @@ DBusCallManager::setModerator(const std::string& accountId, const std::string& peerId, const bool& state) { - DRing::setModerator(accountId, confId, peerId, state); + libjami::setModerator(accountId, confId, peerId, state); } void @@ -420,7 +420,7 @@ DBusCallManager::muteParticipant(const std::string& accountId, const std::string& peerId, const bool& state) { - DRing::muteParticipant(accountId, confId, peerId, state); + libjami::muteParticipant(accountId, confId, peerId, state); } void @@ -429,7 +429,7 @@ DBusCallManager::hangupParticipant(const std::string& accountId, const std::string& peerId, const std::string& deviceId) { - DRing::hangupParticipant(accountId, confId, peerId, deviceId); + libjami::hangupParticipant(accountId, confId, peerId, deviceId); } void @@ -438,5 +438,5 @@ DBusCallManager::raiseParticipantHand(const std::string& accountId, const std::string& peerId, const bool& state) { - DRing::raiseParticipantHand(accountId, confId, peerId, state); + libjami::raiseParticipantHand(accountId, confId, peerId, state); } diff --git a/bin/dbus/dbuscallmanager.h b/bin/dbus/dbuscallmanager.h index 860ce4c14..f72df28ed 100644 --- a/bin/dbus/dbuscallmanager.h +++ b/bin/dbus/dbuscallmanager.h @@ -47,7 +47,7 @@ #include "callmanager_interface.h" #include -class DRING_PUBLIC DBusCallManager : public cx::ring::Ring::CallManager_adaptor, +class LIBJAMI_PUBLIC DBusCallManager : public cx::ring::Ring::CallManager_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor { @@ -121,7 +121,7 @@ public: std::string getConferenceId(const std::string& accountId, const std::string& callId); std::map getConferenceDetails(const std::string& accountId, const std::string& confId); - std::vector currentMediaList(const std::string& accountId, + std::vector currentMediaList(const std::string& accountId, const std::string& callId); bool startRecordedFilePlayback(const std::string& filepath); void stopRecordedFilePlayback(); diff --git a/bin/dbus/dbusclient.cpp b/bin/dbus/dbusclient.cpp index 5170d948d..22179f059 100644 --- a/bin/dbus/dbusclient.cpp +++ b/bin/dbus/dbusclient.cpp @@ -115,7 +115,7 @@ DBusClient::~DBusClient() { // instances destruction order is important // so we enforce it here - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); #ifdef ENABLE_VIDEO videoManager_.reset(); #endif @@ -134,22 +134,22 @@ DBusClient::initLibrary(int flags) using namespace std::placeholders; using std::bind; - using DRing::exportable_callback; - using DRing::CallSignal; - using DRing::ConfigurationSignal; - using DRing::PresenceSignal; - using DRing::AudioSignal; - using DRing::DataTransferSignal; - using DRing::ConversationSignal; + using libjami::exportable_callback; + using libjami::CallSignal; + using libjami::ConfigurationSignal; + using libjami::PresenceSignal; + using libjami::AudioSignal; + using libjami::DataTransferSignal; + using libjami::ConversationSignal; - using SharedCallback = std::shared_ptr; + using SharedCallback = std::shared_ptr; auto callM = callManager_.get(); auto confM = configurationManager_.get(); auto presM = presenceManager_.get(); #ifdef ENABLE_VIDEO - using DRing::VideoSignal; + using libjami::VideoSignal; auto videoM = videoManager_.get(); #endif @@ -335,28 +335,28 @@ DBusClient::initLibrary(int flags) #ifdef ENABLE_PLUGIN // Plugin event handlers const std::map pluginEvHandlers = { - exportable_callback( + exportable_callback( bind(&DBusPluginManagerInterface::webViewMessageReceived, pluginM, _1, _2, _3, _4)), }; #endif - if (!DRing::init(static_cast(flags))) + if (!libjami::init(static_cast(flags))) return -1; - DRing::registerSignalHandlers(callEvHandlers); - DRing::registerSignalHandlers(configEvHandlers); - DRing::registerSignalHandlers(presEvHandlers); - DRing::registerSignalHandlers(audioEvHandlers); - DRing::registerSignalHandlers(dataXferEvHandlers); - DRing::registerSignalHandlers(convEvHandlers); + libjami::registerSignalHandlers(callEvHandlers); + libjami::registerSignalHandlers(configEvHandlers); + libjami::registerSignalHandlers(presEvHandlers); + libjami::registerSignalHandlers(audioEvHandlers); + libjami::registerSignalHandlers(dataXferEvHandlers); + libjami::registerSignalHandlers(convEvHandlers); #ifdef ENABLE_VIDEO - DRing::registerSignalHandlers(videoEvHandlers); + libjami::registerSignalHandlers(videoEvHandlers); #endif #ifdef ENABLE_PLUGIN - DRing::registerSignalHandlers(pluginEvHandlers); + libjami::registerSignalHandlers(pluginEvHandlers); #endif - if (!DRing::start()) + if (!libjami::start()) return -1; return 0; } @@ -364,7 +364,7 @@ DBusClient::initLibrary(int flags) void DBusClient::finiLibrary() noexcept { - DRing::fini(); + libjami::fini(); } int diff --git a/bin/dbus/dbusclient.h b/bin/dbus/dbusclient.h index db69873c3..1ce01d131 100644 --- a/bin/dbus/dbusclient.h +++ b/bin/dbus/dbusclient.h @@ -47,7 +47,7 @@ namespace DBus { class DefaultTimeout; } -class DRING_PUBLIC DBusClient { +class LIBJAMI_PUBLIC DBusClient { public: DBusClient(int flags, bool persistent); ~DBusClient(); diff --git a/bin/dbus/dbusconfigurationmanager.cpp b/bin/dbus/dbusconfigurationmanager.cpp index 57466c0c9..96da8b25a 100644 --- a/bin/dbus/dbusconfigurationmanager.cpp +++ b/bin/dbus/dbusconfigurationmanager.cpp @@ -29,164 +29,164 @@ DBusConfigurationManager::DBusConfigurationManager(DBus::Connection& connection) auto DBusConfigurationManager::getAccountDetails(const std::string& accountID) - -> decltype(DRing::getAccountDetails(accountID)) + -> decltype(libjami::getAccountDetails(accountID)) { - return DRing::getAccountDetails(accountID); + return libjami::getAccountDetails(accountID); } auto DBusConfigurationManager::getVolatileAccountDetails(const std::string& accountID) - -> decltype(DRing::getVolatileAccountDetails(accountID)) + -> decltype(libjami::getVolatileAccountDetails(accountID)) { - return DRing::getVolatileAccountDetails(accountID); + return libjami::getVolatileAccountDetails(accountID); } void DBusConfigurationManager::setAccountDetails(const std::string& accountID, const std::map& details) { - DRing::setAccountDetails(accountID, details); + libjami::setAccountDetails(accountID, details); } void DBusConfigurationManager::setAccountActive(const std::string& accountID, const bool& active) { - DRing::setAccountActive(accountID, active); + libjami::setAccountActive(accountID, active); } auto DBusConfigurationManager::getAccountTemplate(const std::string& accountType) - -> decltype(DRing::getAccountTemplate(accountType)) + -> decltype(libjami::getAccountTemplate(accountType)) { - return DRing::getAccountTemplate(accountType); + return libjami::getAccountTemplate(accountType); } auto DBusConfigurationManager::addAccount(const std::map& details) - -> decltype(DRing::addAccount(details)) + -> decltype(libjami::addAccount(details)) { - return DRing::addAccount(details); + return libjami::addAccount(details); } auto -DBusConfigurationManager::monitor(const bool& continuous) -> decltype(DRing::monitor(continuous)) +DBusConfigurationManager::monitor(const bool& continuous) -> decltype(libjami::monitor(continuous)) { - return DRing::monitor(continuous); + return libjami::monitor(continuous); } auto DBusConfigurationManager::exportOnRing(const std::string& accountID, const std::string& password) - -> decltype(DRing::exportOnRing(accountID, password)) + -> decltype(libjami::exportOnRing(accountID, password)) { - return DRing::exportOnRing(accountID, password); + return libjami::exportOnRing(accountID, password); } auto DBusConfigurationManager::exportToFile(const std::string& accountID, const std::string& destinationPath, const std::string& password) - -> decltype(DRing::exportToFile(accountID, destinationPath, password)) + -> decltype(libjami::exportToFile(accountID, destinationPath, password)) { - return DRing::exportToFile(accountID, destinationPath, password); + return libjami::exportToFile(accountID, destinationPath, password); } auto DBusConfigurationManager::revokeDevice(const std::string& accountID, const std::string& password, const std::string& device) - -> decltype(DRing::revokeDevice(accountID, password, device)) + -> decltype(libjami::revokeDevice(accountID, password, device)) { - return DRing::revokeDevice(accountID, password, device); + return libjami::revokeDevice(accountID, password, device); } auto DBusConfigurationManager::getKnownRingDevices(const std::string& accountID) - -> decltype(DRing::getKnownRingDevices(accountID)) + -> decltype(libjami::getKnownRingDevices(accountID)) { - return DRing::getKnownRingDevices(accountID); + return libjami::getKnownRingDevices(accountID); } auto DBusConfigurationManager::changeAccountPassword(const std::string& accountID, const std::string& password_old, const std::string& password_new) - -> decltype(DRing::changeAccountPassword(accountID, password_old, password_new)) + -> decltype(libjami::changeAccountPassword(accountID, password_old, password_new)) { - return DRing::changeAccountPassword(accountID, password_old, password_new); + return libjami::changeAccountPassword(accountID, password_old, password_new); } auto DBusConfigurationManager::lookupName(const std::string& account, const std::string& nameserver, const std::string& name) - -> decltype(DRing::lookupName(account, nameserver, name)) + -> decltype(libjami::lookupName(account, nameserver, name)) { - return DRing::lookupName(account, nameserver, name); + return libjami::lookupName(account, nameserver, name); } auto DBusConfigurationManager::lookupAddress(const std::string& account, const std::string& nameserver, const std::string& address) - -> decltype(DRing::lookupAddress(account, nameserver, address)) + -> decltype(libjami::lookupAddress(account, nameserver, address)) { - return DRing::lookupAddress(account, nameserver, address); + return libjami::lookupAddress(account, nameserver, address); } auto DBusConfigurationManager::registerName(const std::string& account, const std::string& password, const std::string& name) - -> decltype(DRing::registerName(account, password, name)) + -> decltype(libjami::registerName(account, password, name)) { - return DRing::registerName(account, password, name); + return libjami::registerName(account, password, name); } auto DBusConfigurationManager::searchUser(const std::string& account, const std::string& query) - -> decltype(DRing::searchUser(account, query)) + -> decltype(libjami::searchUser(account, query)) { - return DRing::searchUser(account, query); + return libjami::searchUser(account, query); } void DBusConfigurationManager::removeAccount(const std::string& accountID) { - DRing::removeAccount(accountID); + libjami::removeAccount(accountID); } auto -DBusConfigurationManager::getAccountList() -> decltype(DRing::getAccountList()) +DBusConfigurationManager::getAccountList() -> decltype(libjami::getAccountList()) { - return DRing::getAccountList(); + return libjami::getAccountList(); } void DBusConfigurationManager::sendRegister(const std::string& accountID, const bool& enable) { - DRing::sendRegister(accountID, enable); + libjami::sendRegister(accountID, enable); } void DBusConfigurationManager::registerAllAccounts(void) { - DRing::registerAllAccounts(); + libjami::registerAllAccounts(); } auto DBusConfigurationManager::sendTextMessage(const std::string& accountID, const std::string& to, const std::map& payloads) - -> decltype(DRing::sendAccountTextMessage(accountID, to, payloads)) + -> decltype(libjami::sendAccountTextMessage(accountID, to, payloads)) { - return DRing::sendAccountTextMessage(accountID, to, payloads); + return libjami::sendAccountTextMessage(accountID, to, payloads); } std::vector DBusConfigurationManager::getLastMessages(const std::string& accountID, const uint64_t& base_timestamp) { - auto messages = DRing::getLastMessages(accountID, base_timestamp); + auto messages = libjami::getLastMessages(accountID, base_timestamp); std::vector result; for (const auto& message : messages) { RingDBusMessage m; @@ -201,27 +201,27 @@ DBusConfigurationManager::getLastMessages(const std::string& accountID, std::map DBusConfigurationManager::getNearbyPeers(const std::string& accountID) { - return DRing::getNearbyPeers(accountID); + return libjami::getNearbyPeers(accountID); } auto DBusConfigurationManager::getMessageStatus(const uint64_t& id) - -> decltype(DRing::getMessageStatus(id)) + -> decltype(libjami::getMessageStatus(id)) { - return DRing::getMessageStatus(id); + return libjami::getMessageStatus(id); } auto DBusConfigurationManager::getMessageStatus(const std::string& accountID, const uint64_t& id) - -> decltype(DRing::getMessageStatus(accountID, id)) + -> decltype(libjami::getMessageStatus(accountID, id)) { - return DRing::getMessageStatus(accountID, id); + return libjami::getMessageStatus(accountID, id); } bool DBusConfigurationManager::cancelMessage(const std::string& accountID, const uint64_t& id) { - return DRing::cancelMessage(accountID, id); + return libjami::cancelMessage(accountID, id); } void @@ -229,7 +229,7 @@ DBusConfigurationManager::setIsComposing(const std::string& accountID, const std::string& conversationUri, const bool& isWriting) { - DRing::setIsComposing(accountID, conversationUri, isWriting); + libjami::setIsComposing(accountID, conversationUri, isWriting); } bool @@ -238,304 +238,304 @@ DBusConfigurationManager::setMessageDisplayed(const std::string& accountID, const std::string& messageId, const int32_t& status) { - return DRing::setMessageDisplayed(accountID, conversationUri, messageId, status); + return libjami::setMessageDisplayed(accountID, conversationUri, messageId, status); } auto -DBusConfigurationManager::getCodecList() -> decltype(DRing::getCodecList()) +DBusConfigurationManager::getCodecList() -> decltype(libjami::getCodecList()) { - return DRing::getCodecList(); + return libjami::getCodecList(); } auto -DBusConfigurationManager::getSupportedTlsMethod() -> decltype(DRing::getSupportedTlsMethod()) +DBusConfigurationManager::getSupportedTlsMethod() -> decltype(libjami::getSupportedTlsMethod()) { - return DRing::getSupportedTlsMethod(); + return libjami::getSupportedTlsMethod(); } auto DBusConfigurationManager::getSupportedCiphers(const std::string& accountID) - -> decltype(DRing::getSupportedCiphers(accountID)) + -> decltype(libjami::getSupportedCiphers(accountID)) { - return DRing::getSupportedCiphers(accountID); + return libjami::getSupportedCiphers(accountID); } auto DBusConfigurationManager::getCodecDetails(const std::string& accountID, const unsigned& codecId) - -> decltype(DRing::getCodecDetails(accountID, codecId)) + -> decltype(libjami::getCodecDetails(accountID, codecId)) { - return DRing::getCodecDetails(accountID, codecId); + return libjami::getCodecDetails(accountID, codecId); } auto DBusConfigurationManager::setCodecDetails(const std::string& accountID, const unsigned& codecId, const std::map& details) - -> decltype(DRing::setCodecDetails(accountID, codecId, details)) + -> decltype(libjami::setCodecDetails(accountID, codecId, details)) { - return DRing::setCodecDetails(accountID, codecId, details); + return libjami::setCodecDetails(accountID, codecId, details); } auto DBusConfigurationManager::getActiveCodecList(const std::string& accountID) - -> decltype(DRing::getActiveCodecList(accountID)) + -> decltype(libjami::getActiveCodecList(accountID)) { - return DRing::getActiveCodecList(accountID); + return libjami::getActiveCodecList(accountID); } void DBusConfigurationManager::setActiveCodecList(const std::string& accountID, const std::vector& list) { - DRing::setActiveCodecList(accountID, list); + libjami::setActiveCodecList(accountID, list); } auto -DBusConfigurationManager::getAudioPluginList() -> decltype(DRing::getAudioPluginList()) +DBusConfigurationManager::getAudioPluginList() -> decltype(libjami::getAudioPluginList()) { - return DRing::getAudioPluginList(); + return libjami::getAudioPluginList(); } void DBusConfigurationManager::setAudioPlugin(const std::string& audioPlugin) { - DRing::setAudioPlugin(audioPlugin); + libjami::setAudioPlugin(audioPlugin); } auto -DBusConfigurationManager::getAudioOutputDeviceList() -> decltype(DRing::getAudioOutputDeviceList()) +DBusConfigurationManager::getAudioOutputDeviceList() -> decltype(libjami::getAudioOutputDeviceList()) { - return DRing::getAudioOutputDeviceList(); + return libjami::getAudioOutputDeviceList(); } void DBusConfigurationManager::setAudioOutputDevice(const int32_t& index) { - DRing::setAudioOutputDevice(index); + libjami::setAudioOutputDevice(index); } void DBusConfigurationManager::setAudioInputDevice(const int32_t& index) { - DRing::setAudioInputDevice(index); + libjami::setAudioInputDevice(index); } void DBusConfigurationManager::setAudioRingtoneDevice(const int32_t& index) { - DRing::setAudioRingtoneDevice(index); + libjami::setAudioRingtoneDevice(index); } auto -DBusConfigurationManager::getAudioInputDeviceList() -> decltype(DRing::getAudioInputDeviceList()) +DBusConfigurationManager::getAudioInputDeviceList() -> decltype(libjami::getAudioInputDeviceList()) { - return DRing::getAudioInputDeviceList(); + return libjami::getAudioInputDeviceList(); } auto DBusConfigurationManager::getCurrentAudioDevicesIndex() - -> decltype(DRing::getCurrentAudioDevicesIndex()) + -> decltype(libjami::getCurrentAudioDevicesIndex()) { - return DRing::getCurrentAudioDevicesIndex(); + return libjami::getCurrentAudioDevicesIndex(); } auto DBusConfigurationManager::getAudioInputDeviceIndex(const std::string& name) - -> decltype(DRing::getAudioInputDeviceIndex(name)) + -> decltype(libjami::getAudioInputDeviceIndex(name)) { - return DRing::getAudioInputDeviceIndex(name); + return libjami::getAudioInputDeviceIndex(name); } auto DBusConfigurationManager::getAudioOutputDeviceIndex(const std::string& name) - -> decltype(DRing::getAudioOutputDeviceIndex(name)) + -> decltype(libjami::getAudioOutputDeviceIndex(name)) { - return DRing::getAudioOutputDeviceIndex(name); + return libjami::getAudioOutputDeviceIndex(name); } auto DBusConfigurationManager::getCurrentAudioOutputPlugin() - -> decltype(DRing::getCurrentAudioOutputPlugin()) + -> decltype(libjami::getCurrentAudioOutputPlugin()) { - return DRing::getCurrentAudioOutputPlugin(); + return libjami::getCurrentAudioOutputPlugin(); } auto -DBusConfigurationManager::getNoiseSuppressState() -> decltype(DRing::getNoiseSuppressState()) +DBusConfigurationManager::getNoiseSuppressState() -> decltype(libjami::getNoiseSuppressState()) { - return DRing::getNoiseSuppressState(); + return libjami::getNoiseSuppressState(); } void DBusConfigurationManager::setNoiseSuppressState(const bool& state) { - DRing::setNoiseSuppressState(state); + libjami::setNoiseSuppressState(state); } auto -DBusConfigurationManager::isAgcEnabled() -> decltype(DRing::isAgcEnabled()) +DBusConfigurationManager::isAgcEnabled() -> decltype(libjami::isAgcEnabled()) { - return DRing::isAgcEnabled(); + return libjami::isAgcEnabled(); } void DBusConfigurationManager::setAgcState(const bool& enabled) { - DRing::setAgcState(enabled); + libjami::setAgcState(enabled); } void DBusConfigurationManager::muteDtmf(const bool& mute) { - DRing::muteDtmf(mute); + libjami::muteDtmf(mute); } auto -DBusConfigurationManager::isDtmfMuted() -> decltype(DRing::isDtmfMuted()) +DBusConfigurationManager::isDtmfMuted() -> decltype(libjami::isDtmfMuted()) { - return DRing::isDtmfMuted(); + return libjami::isDtmfMuted(); } auto -DBusConfigurationManager::isCaptureMuted() -> decltype(DRing::isCaptureMuted()) +DBusConfigurationManager::isCaptureMuted() -> decltype(libjami::isCaptureMuted()) { - return DRing::isCaptureMuted(); + return libjami::isCaptureMuted(); } void DBusConfigurationManager::muteCapture(const bool& mute) { - DRing::muteCapture(mute); + libjami::muteCapture(mute); } auto -DBusConfigurationManager::isPlaybackMuted() -> decltype(DRing::isPlaybackMuted()) +DBusConfigurationManager::isPlaybackMuted() -> decltype(libjami::isPlaybackMuted()) { - return DRing::isPlaybackMuted(); + return libjami::isPlaybackMuted(); } void DBusConfigurationManager::mutePlayback(const bool& mute) { - DRing::mutePlayback(mute); + libjami::mutePlayback(mute); } auto -DBusConfigurationManager::isRingtoneMuted() -> decltype(DRing::isRingtoneMuted()) +DBusConfigurationManager::isRingtoneMuted() -> decltype(libjami::isRingtoneMuted()) { - return DRing::isRingtoneMuted(); + return libjami::isRingtoneMuted(); } void DBusConfigurationManager::muteRingtone(const bool& mute) { - DRing::muteRingtone(mute); + libjami::muteRingtone(mute); } auto -DBusConfigurationManager::getAudioManager() -> decltype(DRing::getAudioManager()) +DBusConfigurationManager::getAudioManager() -> decltype(libjami::getAudioManager()) { - return DRing::getAudioManager(); + return libjami::getAudioManager(); } auto DBusConfigurationManager::setAudioManager(const std::string& api) - -> decltype(DRing::setAudioManager(api)) + -> decltype(libjami::setAudioManager(api)) { - return DRing::setAudioManager(api); + return libjami::setAudioManager(api); } auto DBusConfigurationManager::getSupportedAudioManagers() - -> decltype(DRing::getSupportedAudioManagers()) + -> decltype(libjami::getSupportedAudioManagers()) { - return DRing::getSupportedAudioManagers(); + return libjami::getSupportedAudioManagers(); } auto -DBusConfigurationManager::getRecordPath() -> decltype(DRing::getRecordPath()) +DBusConfigurationManager::getRecordPath() -> decltype(libjami::getRecordPath()) { - return DRing::getRecordPath(); + return libjami::getRecordPath(); } void DBusConfigurationManager::setRecordPath(const std::string& recPath) { - DRing::setRecordPath(recPath); + libjami::setRecordPath(recPath); } auto -DBusConfigurationManager::getIsAlwaysRecording() -> decltype(DRing::getIsAlwaysRecording()) +DBusConfigurationManager::getIsAlwaysRecording() -> decltype(libjami::getIsAlwaysRecording()) { - return DRing::getIsAlwaysRecording(); + return libjami::getIsAlwaysRecording(); } void DBusConfigurationManager::setIsAlwaysRecording(const bool& rec) { - DRing::setIsAlwaysRecording(rec); + libjami::setIsAlwaysRecording(rec); } auto -DBusConfigurationManager::getRecordPreview() -> decltype(DRing::getRecordPreview()) +DBusConfigurationManager::getRecordPreview() -> decltype(libjami::getRecordPreview()) { - return DRing::getRecordPreview(); + return libjami::getRecordPreview(); } void DBusConfigurationManager::setRecordPreview(const bool& rec) { - DRing::setRecordPreview(rec); + libjami::setRecordPreview(rec); } auto -DBusConfigurationManager::getRecordQuality() -> decltype(DRing::getRecordQuality()) +DBusConfigurationManager::getRecordQuality() -> decltype(libjami::getRecordQuality()) { - return DRing::getRecordQuality(); + return libjami::getRecordQuality(); } void DBusConfigurationManager::setRecordQuality(const int32_t& quality) { - DRing::setRecordQuality(quality); + libjami::setRecordQuality(quality); } void DBusConfigurationManager::setHistoryLimit(const int32_t& days) { - DRing::setHistoryLimit(days); + libjami::setHistoryLimit(days); } auto -DBusConfigurationManager::getHistoryLimit() -> decltype(DRing::getHistoryLimit()) +DBusConfigurationManager::getHistoryLimit() -> decltype(libjami::getHistoryLimit()) { - return DRing::getHistoryLimit(); + return libjami::getHistoryLimit(); } void DBusConfigurationManager::setRingingTimeout(const int32_t& timeout) { - DRing::setRingingTimeout(timeout); + libjami::setRingingTimeout(timeout); } auto -DBusConfigurationManager::getRingingTimeout() -> decltype(DRing::getRingingTimeout()) +DBusConfigurationManager::getRingingTimeout() -> decltype(libjami::getRingingTimeout()) { - return DRing::getRingingTimeout(); + return libjami::getRingingTimeout(); } void DBusConfigurationManager::setAccountsOrder(const std::string& order) { - DRing::setAccountsOrder(order); + libjami::setAccountsOrder(order); } auto DBusConfigurationManager::validateCertificate(const std::string& accountId, const std::string& certificate) - -> decltype(DRing::validateCertificate(accountId, certificate)) + -> decltype(libjami::validateCertificate(accountId, certificate)) { - return DRing::validateCertificate(accountId, certificate); + return libjami::validateCertificate(accountId, certificate); } auto @@ -544,105 +544,105 @@ DBusConfigurationManager::validateCertificatePath(const std::string& accountId, const std::string& privateKey, const std::string& privateKeyPass, const std::string& caList) - -> decltype(DRing::validateCertificatePath( + -> decltype(libjami::validateCertificatePath( accountId, certificate, privateKey, privateKeyPass, caList)) { - return DRing::validateCertificatePath(accountId, certificate, privateKey, privateKeyPass, caList); + return libjami::validateCertificatePath(accountId, certificate, privateKey, privateKeyPass, caList); } auto DBusConfigurationManager::getCertificateDetails(const std::string& certificate) - -> decltype(DRing::getCertificateDetails(certificate)) + -> decltype(libjami::getCertificateDetails(certificate)) { - return DRing::getCertificateDetails(certificate); + return libjami::getCertificateDetails(certificate); } auto DBusConfigurationManager::getCertificateDetailsPath(const std::string& certificate, const std::string& privateKey, const std::string& privateKeyPass) - -> decltype(DRing::getCertificateDetailsPath(certificate, privateKey, privateKeyPass)) + -> decltype(libjami::getCertificateDetailsPath(certificate, privateKey, privateKeyPass)) { - return DRing::getCertificateDetailsPath(certificate, privateKey, privateKeyPass); + return libjami::getCertificateDetailsPath(certificate, privateKey, privateKeyPass); } auto -DBusConfigurationManager::getPinnedCertificates() -> decltype(DRing::getPinnedCertificates()) +DBusConfigurationManager::getPinnedCertificates() -> decltype(libjami::getPinnedCertificates()) { - return DRing::getPinnedCertificates(); + return libjami::getPinnedCertificates(); } auto DBusConfigurationManager::pinCertificate(const std::vector& certificate, const bool& local) - -> decltype(DRing::pinCertificate(certificate, local)) + -> decltype(libjami::pinCertificate(certificate, local)) { - return DRing::pinCertificate(certificate, local); + return libjami::pinCertificate(certificate, local); } void DBusConfigurationManager::pinCertificatePath(const std::string& certPath) { - return DRing::pinCertificatePath(certPath); + return libjami::pinCertificatePath(certPath); } auto DBusConfigurationManager::unpinCertificate(const std::string& certId) - -> decltype(DRing::unpinCertificate(certId)) + -> decltype(libjami::unpinCertificate(certId)) { - return DRing::unpinCertificate(certId); + return libjami::unpinCertificate(certId); } auto DBusConfigurationManager::unpinCertificatePath(const std::string& p) - -> decltype(DRing::unpinCertificatePath(p)) + -> decltype(libjami::unpinCertificatePath(p)) { - return DRing::unpinCertificatePath(p); + return libjami::unpinCertificatePath(p); } auto DBusConfigurationManager::pinRemoteCertificate(const std::string& accountId, const std::string& certId) - -> decltype(DRing::pinRemoteCertificate(accountId, certId)) + -> decltype(libjami::pinRemoteCertificate(accountId, certId)) { - return DRing::pinRemoteCertificate(accountId, certId); + return libjami::pinRemoteCertificate(accountId, certId); } auto DBusConfigurationManager::setCertificateStatus(const std::string& accountId, const std::string& certId, const std::string& status) - -> decltype(DRing::setCertificateStatus(accountId, certId, status)) + -> decltype(libjami::setCertificateStatus(accountId, certId, status)) { - return DRing::setCertificateStatus(accountId, certId, status); + return libjami::setCertificateStatus(accountId, certId, status); } auto DBusConfigurationManager::getCertificatesByStatus(const std::string& accountId, const std::string& status) - -> decltype(DRing::getCertificatesByStatus(accountId, status)) + -> decltype(libjami::getCertificatesByStatus(accountId, status)) { - return DRing::getCertificatesByStatus(accountId, status); + return libjami::getCertificatesByStatus(accountId, status); } auto DBusConfigurationManager::getTrustRequests(const std::string& accountId) - -> decltype(DRing::getTrustRequests(accountId)) + -> decltype(libjami::getTrustRequests(accountId)) { - return DRing::getTrustRequests(accountId); + return libjami::getTrustRequests(accountId); } auto DBusConfigurationManager::acceptTrustRequest(const std::string& accountId, const std::string& from) - -> decltype(DRing::acceptTrustRequest(accountId, from)) + -> decltype(libjami::acceptTrustRequest(accountId, from)) { - return DRing::acceptTrustRequest(accountId, from); + return libjami::acceptTrustRequest(accountId, from); } auto DBusConfigurationManager::discardTrustRequest(const std::string& accountId, const std::string& from) - -> decltype(DRing::discardTrustRequest(accountId, from)) + -> decltype(libjami::discardTrustRequest(accountId, from)) { - return DRing::discardTrustRequest(accountId, from); + return libjami::discardTrustRequest(accountId, from); } void @@ -650,13 +650,13 @@ DBusConfigurationManager::sendTrustRequest(const std::string& accountId, const std::string& to, const std::vector& payload) { - DRing::sendTrustRequest(accountId, to, payload); + libjami::sendTrustRequest(accountId, to, payload); } void DBusConfigurationManager::addContact(const std::string& accountId, const std::string& uri) { - DRing::addContact(accountId, uri); + libjami::addContact(accountId, uri); } void @@ -664,82 +664,82 @@ DBusConfigurationManager::removeContact(const std::string& accountId, const std::string& uri, const bool& ban) { - DRing::removeContact(accountId, uri, ban); + libjami::removeContact(accountId, uri, ban); } auto DBusConfigurationManager::getContactDetails(const std::string& accountId, const std::string& uri) - -> decltype(DRing::getContactDetails(accountId, uri)) + -> decltype(libjami::getContactDetails(accountId, uri)) { - return DRing::getContactDetails(accountId, uri); + return libjami::getContactDetails(accountId, uri); } auto DBusConfigurationManager::getContacts(const std::string& accountId) - -> decltype(DRing::getContacts(accountId)) + -> decltype(libjami::getContacts(accountId)) { - return DRing::getContacts(accountId); + return libjami::getContacts(accountId); } auto DBusConfigurationManager::getCredentials(const std::string& accountID) - -> decltype(DRing::getCredentials(accountID)) + -> decltype(libjami::getCredentials(accountID)) { - return DRing::getCredentials(accountID); + return libjami::getCredentials(accountID); } void DBusConfigurationManager::setCredentials( const std::string& accountID, const std::vector>& details) { - DRing::setCredentials(accountID, details); + libjami::setCredentials(accountID, details); } auto DBusConfigurationManager::getAddrFromInterfaceName(const std::string& interface) - -> decltype(DRing::getAddrFromInterfaceName(interface)) + -> decltype(libjami::getAddrFromInterfaceName(interface)) { - return DRing::getAddrFromInterfaceName(interface); + return libjami::getAddrFromInterfaceName(interface); } auto -DBusConfigurationManager::getAllIpInterface() -> decltype(DRing::getAllIpInterface()) +DBusConfigurationManager::getAllIpInterface() -> decltype(libjami::getAllIpInterface()) { - return DRing::getAllIpInterface(); + return libjami::getAllIpInterface(); } auto -DBusConfigurationManager::getAllIpInterfaceByName() -> decltype(DRing::getAllIpInterfaceByName()) +DBusConfigurationManager::getAllIpInterfaceByName() -> decltype(libjami::getAllIpInterfaceByName()) { - return DRing::getAllIpInterfaceByName(); + return libjami::getAllIpInterfaceByName(); } void DBusConfigurationManager::setVolume(const std::string& device, const double& value) { - DRing::setVolume(device, value); + libjami::setVolume(device, value); } auto -DBusConfigurationManager::getVolume(const std::string& device) -> decltype(DRing::getVolume(device)) +DBusConfigurationManager::getVolume(const std::string& device) -> decltype(libjami::getVolume(device)) { - return DRing::getVolume(device); + return libjami::getVolume(device); } void DBusConfigurationManager::connectivityChanged() { - DRing::connectivityChanged(); + libjami::connectivityChanged(); } void DBusConfigurationManager::sendFileLegacy(const RingDBusDataTransferInfo& in, uint32_t& error, - DRing::DataTransferId& id) + libjami::DataTransferId& id) { - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = in._1; - info.lastEvent = DRing::DataTransferEventCode(in._2); + info.lastEvent = libjami::DataTransferEventCode(in._2); info.flags = in._3; info.totalSize = in._4; info.bytesProgress = in._5; @@ -749,7 +749,7 @@ DBusConfigurationManager::sendFileLegacy(const RingDBusDataTransferInfo& in, info.displayName = in._9; info.path = in._10; info.mimetype = in._11; - error = uint32_t(DRing::sendFileLegacy(info, id)); + error = uint32_t(libjami::sendFileLegacy(info, id)); } void @@ -759,7 +759,7 @@ DBusConfigurationManager::sendFile(const std::string& accountId, const std::string& displayName, const std::string& replyTo) { - DRing::sendFile(accountId, conversationId, path, displayName, replyTo); + libjami::sendFile(accountId, conversationId, path, displayName, replyTo); } void @@ -768,9 +768,9 @@ DBusConfigurationManager::dataTransferInfo(const std::string& accountId, uint32_t& error, RingDBusDataTransferInfo& out) { - DRing::DataTransferInfo info; - auto res = DRing::dataTransferInfo(accountId, fileId, info); - if (res == DRing::DataTransferError::success) { + libjami::DataTransferInfo info; + auto res = libjami::dataTransferInfo(accountId, fileId, info); + if (res == libjami::DataTransferError::success) { out._1 = info.accountId; out._2 = uint32_t(info.lastEvent); out._3 = info.flags; @@ -796,7 +796,7 @@ DBusConfigurationManager::fileTransferInfo(const std::string& accountId, int64_t& progress) { error = uint32_t( - DRing::fileTransferInfo(accountId, conversationId, fileId, path, total, progress)); + libjami::fileTransferInfo(accountId, conversationId, fileId, path, total, progress)); } uint32_t @@ -804,7 +804,7 @@ DBusConfigurationManager::acceptFileTransfer(const std::string& accountId, const std::string& fileId, const std::string& file_path) { - return uint32_t(DRing::acceptFileTransfer(accountId, fileId, file_path)); + return uint32_t(libjami::acceptFileTransfer(accountId, fileId, file_path)); } bool @@ -814,7 +814,7 @@ DBusConfigurationManager::downloadFile(const std::string& accountId, const std::string& fileId, const std::string& path) { - return DRing::downloadFile(accountId, conversationUri, interactionId, fileId, path); + return libjami::downloadFile(accountId, conversationUri, interactionId, fileId, path); } uint32_t @@ -822,46 +822,46 @@ DBusConfigurationManager::cancelDataTransfer(const std::string& accountId, const std::string& conversationId, const std::string& fileId) { - return uint32_t(DRing::cancelDataTransfer(accountId, conversationId, fileId)); + return uint32_t(libjami::cancelDataTransfer(accountId, conversationId, fileId)); } std::string DBusConfigurationManager::startConversation(const std::string& accountId) { - return DRing::startConversation(accountId); + return libjami::startConversation(accountId); } void DBusConfigurationManager::acceptConversationRequest(const std::string& accountId, const std::string& conversationId) { - DRing::acceptConversationRequest(accountId, conversationId); + libjami::acceptConversationRequest(accountId, conversationId); } void DBusConfigurationManager::declineConversationRequest(const std::string& accountId, const std::string& conversationId) { - DRing::declineConversationRequest(accountId, conversationId); + libjami::declineConversationRequest(accountId, conversationId); } bool DBusConfigurationManager::removeConversation(const std::string& accountId, const std::string& conversationId) { - return DRing::removeConversation(accountId, conversationId); + return libjami::removeConversation(accountId, conversationId); } std::vector DBusConfigurationManager::getConversations(const std::string& accountId) { - return DRing::getConversations(accountId); + return libjami::getConversations(accountId); } std::vector> DBusConfigurationManager::getConversationRequests(const std::string& accountId) { - return DRing::getConversationRequests(accountId); + return libjami::getConversationRequests(accountId); } void @@ -869,14 +869,14 @@ DBusConfigurationManager::updateConversationInfos(const std::string& accountId, const std::string& conversationId, const std::map& infos) { - DRing::updateConversationInfos(accountId, conversationId, infos); + libjami::updateConversationInfos(accountId, conversationId, infos); } std::map DBusConfigurationManager::conversationInfos(const std::string& accountId, const std::string& conversationId) { - return DRing::conversationInfos(accountId, conversationId); + return libjami::conversationInfos(accountId, conversationId); } void @@ -884,14 +884,14 @@ DBusConfigurationManager::setConversationPreferences(const std::string& accountI const std::string& conversationId, const std::map& infos) { - DRing::setConversationPreferences(accountId, conversationId, infos); + libjami::setConversationPreferences(accountId, conversationId, infos); } std::map DBusConfigurationManager::getConversationPreferences(const std::string& accountId, const std::string& conversationId) { - return DRing::getConversationPreferences(accountId, conversationId); + return libjami::getConversationPreferences(accountId, conversationId); } void @@ -899,7 +899,7 @@ DBusConfigurationManager::addConversationMember(const std::string& accountId, const std::string& conversationId, const std::string& contactUri) { - DRing::addConversationMember(accountId, conversationId, contactUri); + libjami::addConversationMember(accountId, conversationId, contactUri); } void @@ -907,14 +907,14 @@ DBusConfigurationManager::removeConversationMember(const std::string& accountId, const std::string& conversationId, const std::string& contactUri) { - DRing::removeConversationMember(accountId, conversationId, contactUri); + libjami::removeConversationMember(accountId, conversationId, contactUri); } std::vector> DBusConfigurationManager::getConversationMembers(const std::string& accountId, const std::string& conversationId) { - return DRing::getConversationMembers(accountId, conversationId); + return libjami::getConversationMembers(accountId, conversationId); } void @@ -924,7 +924,7 @@ DBusConfigurationManager::sendMessage(const std::string& accountId, const std::string& replyTo, const int32_t& flag) { - DRing::sendMessage(accountId, conversationId, message, replyTo, flag); + libjami::sendMessage(accountId, conversationId, message, replyTo, flag); } uint32_t @@ -933,7 +933,7 @@ DBusConfigurationManager::loadConversationMessages(const std::string& accountId, const std::string& fromMessage, const uint32_t& n) { - return DRing::loadConversationMessages(accountId, conversationId, fromMessage, n); + return libjami::loadConversationMessages(accountId, conversationId, fromMessage, n); } uint32_t @@ -942,7 +942,7 @@ DBusConfigurationManager::loadConversationUntil(const std::string& accountId, const std::string& fromMessage, const std::string& to) { - return DRing::loadConversationUntil(accountId, conversationId, fromMessage, to); + return libjami::loadConversationUntil(accountId, conversationId, fromMessage, to); } uint32_t @@ -952,7 +952,7 @@ DBusConfigurationManager::countInteractions(const std::string& accountId, const std::string& fromId, const std::string& authorUri) { - return DRing::countInteractions(accountId, conversationId, toId, fromId, authorUri); + return libjami::countInteractions(accountId, conversationId, toId, fromId, authorUri); } uint32_t @@ -966,7 +966,7 @@ DBusConfigurationManager::searchConversation(const std::string& accountId, const int64_t& before, const uint32_t& maxResult) { - return DRing::searchConversation(accountId, + return libjami::searchConversation(accountId, conversationId, author, lastId, @@ -980,13 +980,13 @@ DBusConfigurationManager::searchConversation(const std::string& accountId, bool DBusConfigurationManager::isAudioMeterActive(const std::string& id) { - return DRing::isAudioMeterActive(id); + return libjami::isAudioMeterActive(id); } void DBusConfigurationManager::setAudioMeterState(const std::string& id, const bool& state) { - return DRing::setAudioMeterState(id, state); + return libjami::setAudioMeterState(id, state); } void @@ -994,37 +994,37 @@ DBusConfigurationManager::setDefaultModerator(const std::string& accountID, const std::string& peerURI, const bool& state) { - DRing::setDefaultModerator(accountID, peerURI, state); + libjami::setDefaultModerator(accountID, peerURI, state); } auto DBusConfigurationManager::getDefaultModerators(const std::string& accountID) - -> decltype(DRing::getDefaultModerators(accountID)) + -> decltype(libjami::getDefaultModerators(accountID)) { - return DRing::getDefaultModerators(accountID); + return libjami::getDefaultModerators(accountID); } void DBusConfigurationManager::enableLocalModerators(const std::string& accountID, const bool& isModEnabled) { - return DRing::enableLocalModerators(accountID, isModEnabled); + return libjami::enableLocalModerators(accountID, isModEnabled); } bool DBusConfigurationManager::isLocalModeratorsEnabled(const std::string& accountID) { - return DRing::isLocalModeratorsEnabled(accountID); + return libjami::isLocalModeratorsEnabled(accountID); } void DBusConfigurationManager::setAllModerators(const std::string& accountID, const bool& allModerators) { - return DRing::setAllModerators(accountID, allModerators); + return libjami::setAllModerators(accountID, allModerators); } bool DBusConfigurationManager::isAllModerators(const std::string& accountID) { - return DRing::isAllModerators(accountID); + return libjami::isAllModerators(accountID); } \ No newline at end of file diff --git a/bin/dbus/dbusconfigurationmanager.h b/bin/dbus/dbusconfigurationmanager.h index f317cd436..6013d817b 100644 --- a/bin/dbus/dbusconfigurationmanager.h +++ b/bin/dbus/dbusconfigurationmanager.h @@ -52,7 +52,7 @@ using RingDBusMessage = DBus::Struct, uint64_t>; -class DRING_PUBLIC DBusConfigurationManager : public cx::ring::Ring::ConfigurationManager_adaptor, +class LIBJAMI_PUBLIC DBusConfigurationManager : public cx::ring::Ring::ConfigurationManager_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor { @@ -215,7 +215,7 @@ public: void connectivityChanged(); void sendFileLegacy(const RingDBusDataTransferInfo& info, uint32_t& error, - DRing::DataTransferId& id); + libjami::DataTransferId& id); void sendFile(const std::string& accountId, const std::string& conversationId, const std::string& path, diff --git a/bin/dbus/dbusinstance.h b/bin/dbus/dbusinstance.h index 73457af0d..33dc437ea 100644 --- a/bin/dbus/dbusinstance.h +++ b/bin/dbus/dbusinstance.h @@ -39,7 +39,7 @@ #pragma GCC diagnostic warning "-Wunused-but-set-variable" #endif -class DRING_PUBLIC DBusInstance : +class LIBJAMI_PUBLIC DBusInstance : public cx::ring::Ring::Instance_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor diff --git a/bin/dbus/dbuspluginmanagerinterface.cpp b/bin/dbus/dbuspluginmanagerinterface.cpp index 636b46397..354cb96aa 100644 --- a/bin/dbus/dbuspluginmanagerinterface.cpp +++ b/bin/dbus/dbuspluginmanagerinterface.cpp @@ -28,26 +28,26 @@ DBusPluginManagerInterface::DBusPluginManagerInterface(DBus::Connection& connect bool DBusPluginManagerInterface::loadPlugin(const std::string& path) { - return DRing::loadPlugin(path); + return libjami::loadPlugin(path); } bool DBusPluginManagerInterface::unloadPlugin(const std::string& path) { - return DRing::unloadPlugin(path); + return libjami::unloadPlugin(path); } std::map DBusPluginManagerInterface::getPluginDetails(const std::string& path) { - return DRing::getPluginDetails(path); + return libjami::getPluginDetails(path); } std::vector> DBusPluginManagerInterface::getPluginPreferences(const std::string& path, const std::string& accountId) { - return DRing::getPluginPreferences(path, accountId); + return libjami::getPluginPreferences(path, accountId); } bool @@ -56,64 +56,64 @@ DBusPluginManagerInterface::setPluginPreference(const std::string& path, const std::string& key, const std::string& value) { - return DRing::setPluginPreference(path, accountId, key, value); + return libjami::setPluginPreference(path, accountId, key, value); } std::map DBusPluginManagerInterface::getPluginPreferencesValues(const std::string& path, const std::string& accountId) { - return DRing::getPluginPreferencesValues(path, accountId); + return libjami::getPluginPreferencesValues(path, accountId); } bool DBusPluginManagerInterface::resetPluginPreferencesValues(const std::string& path, const std::string& accountId) { - return DRing::resetPluginPreferencesValues(path, accountId); + return libjami::resetPluginPreferencesValues(path, accountId); } auto -DBusPluginManagerInterface::getInstalledPlugins() -> decltype(DRing::getInstalledPlugins()) +DBusPluginManagerInterface::getInstalledPlugins() -> decltype(libjami::getInstalledPlugins()) { - return DRing::getInstalledPlugins(); + return libjami::getInstalledPlugins(); } auto -DBusPluginManagerInterface::getLoadedPlugins() -> decltype(DRing::getLoadedPlugins()) +DBusPluginManagerInterface::getLoadedPlugins() -> decltype(libjami::getLoadedPlugins()) { - return DRing::getLoadedPlugins(); + return libjami::getLoadedPlugins(); } int DBusPluginManagerInterface::installPlugin(const std::string& jplPath, const bool& force) { - return DRing::installPlugin(jplPath, force); + return libjami::installPlugin(jplPath, force); } int DBusPluginManagerInterface::uninstallPlugin(const std::string& pluginRootPath) { - return DRing::uninstallPlugin(pluginRootPath); + return libjami::uninstallPlugin(pluginRootPath); } auto -DBusPluginManagerInterface::getCallMediaHandlers() -> decltype(DRing::getCallMediaHandlers()) +DBusPluginManagerInterface::getCallMediaHandlers() -> decltype(libjami::getCallMediaHandlers()) { - return DRing::getCallMediaHandlers(); + return libjami::getCallMediaHandlers(); } auto -DBusPluginManagerInterface::getChatHandlers() -> decltype(DRing::getChatHandlers()) +DBusPluginManagerInterface::getChatHandlers() -> decltype(libjami::getChatHandlers()) { - return DRing::getChatHandlers(); + return libjami::getChatHandlers(); } void DBusPluginManagerInterface::toggleCallMediaHandler(const std::string& mediaHandlerId, const std::string& callId, const bool& toggle) { - DRing::toggleCallMediaHandler(mediaHandlerId, callId, toggle); + libjami::toggleCallMediaHandler(mediaHandlerId, callId, toggle); } void @@ -122,44 +122,44 @@ DBusPluginManagerInterface::toggleChatHandler(const std::string& chatHandlerId, const std::string& peerId, const bool& toggle) { - DRing::toggleChatHandler(chatHandlerId, accountId, peerId, toggle); + libjami::toggleChatHandler(chatHandlerId, accountId, peerId, toggle); } std::map DBusPluginManagerInterface::getCallMediaHandlerDetails(const std::string& mediaHanlderId) { - return DRing::getCallMediaHandlerDetails(mediaHanlderId); + return libjami::getCallMediaHandlerDetails(mediaHanlderId); } std::vector DBusPluginManagerInterface::getCallMediaHandlerStatus(const std::string& callId) { - return DRing::getCallMediaHandlerStatus(callId); + return libjami::getCallMediaHandlerStatus(callId); } std::map DBusPluginManagerInterface::getChatHandlerDetails(const std::string& chatHanlderId) { - return DRing::getChatHandlerDetails(chatHanlderId); + return libjami::getChatHandlerDetails(chatHanlderId); } std::vector DBusPluginManagerInterface::getChatHandlerStatus(const std::string& accountId, const std::string& peerId) { - return DRing::getChatHandlerStatus(accountId, peerId); + return libjami::getChatHandlerStatus(accountId, peerId); } bool DBusPluginManagerInterface::getPluginsEnabled() { - return DRing::getPluginsEnabled(); + return libjami::getPluginsEnabled(); } void DBusPluginManagerInterface::setPluginsEnabled(const bool& state) { - DRing::setPluginsEnabled(state); + libjami::setPluginsEnabled(state); } void @@ -168,7 +168,7 @@ DBusPluginManagerInterface::sendWebViewMessage(const std::string& pluginId, const std::string& messageId, const std::string& payload) { - DRing::sendWebViewAttach(pluginId, webViewId, messageId, payload); + libjami::sendWebViewAttach(pluginId, webViewId, messageId, payload); } std::string @@ -177,12 +177,12 @@ DBusPluginManagerInterface::sendWebViewAttach(const std::string& pluginId, const std::string& webViewId, const std::string& action) { - return DRing::sendWebViewAttach(pluginId, accountId, webViewId, action); + return libjami::sendWebViewAttach(pluginId, accountId, webViewId, action); } void DBusPluginManagerInterface::sendWebViewDetach(const std::string& pluginId, const std::string& webViewId) { - DRing::sendWebViewDetach(pluginId, webViewId); + libjami::sendWebViewDetach(pluginId, webViewId); } diff --git a/bin/dbus/dbuspluginmanagerinterface.h b/bin/dbus/dbuspluginmanagerinterface.h index bd93bad65..1c44f6998 100644 --- a/bin/dbus/dbuspluginmanagerinterface.h +++ b/bin/dbus/dbuspluginmanagerinterface.h @@ -43,7 +43,7 @@ #pragma GCC diagnostic warning "-Wunused-but-set-variable" #endif -class DRING_PUBLIC DBusPluginManagerInterface +class LIBJAMI_PUBLIC DBusPluginManagerInterface : public cx::ring::Ring::PluginManagerInterface_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor diff --git a/bin/dbus/dbuspresencemanager.cpp b/bin/dbus/dbuspresencemanager.cpp index d53af85db..358aa0375 100644 --- a/bin/dbus/dbuspresencemanager.cpp +++ b/bin/dbus/dbuspresencemanager.cpp @@ -28,29 +28,29 @@ DBusPresenceManager::DBusPresenceManager(DBus::Connection& connection) void DBusPresenceManager::publish(const std::string& accountID, const bool& status, const std::string& note) { - DRing::publish(accountID, status, note); + libjami::publish(accountID, status, note); } void DBusPresenceManager::answerServerRequest(const std::string& uri, const bool& flag) { - DRing::answerServerRequest(uri, flag); + libjami::answerServerRequest(uri, flag); } void DBusPresenceManager::subscribeBuddy(const std::string& accountID, const std::string& uri, const bool& flag) { - DRing::subscribeBuddy(accountID, uri, flag); + libjami::subscribeBuddy(accountID, uri, flag); } auto -DBusPresenceManager::getSubscriptions(const std::string& accountID) -> decltype(DRing::getSubscriptions(accountID)) +DBusPresenceManager::getSubscriptions(const std::string& accountID) -> decltype(libjami::getSubscriptions(accountID)) { - return DRing::getSubscriptions(accountID); + return libjami::getSubscriptions(accountID); } void DBusPresenceManager::setSubscriptions(const std::string& accountID, const std::vector& uris) { - DRing::setSubscriptions(accountID, uris); + libjami::setSubscriptions(accountID, uris); } diff --git a/bin/dbus/dbuspresencemanager.h b/bin/dbus/dbuspresencemanager.h index 1f1a257f5..97a7e73ff 100644 --- a/bin/dbus/dbuspresencemanager.h +++ b/bin/dbus/dbuspresencemanager.h @@ -44,7 +44,7 @@ #pragma GCC diagnostic warning "-Wunused-but-set-variable" #endif -class DRING_PUBLIC DBusPresenceManager : +class LIBJAMI_PUBLIC DBusPresenceManager : public cx::ring::Ring::PresenceManager_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor diff --git a/bin/dbus/dbusvideomanager.cpp b/bin/dbus/dbusvideomanager.cpp index a040394af..1a51f10cc 100644 --- a/bin/dbus/dbusvideomanager.cpp +++ b/bin/dbus/dbusvideomanager.cpp @@ -26,113 +26,113 @@ DBusVideoManager::DBusVideoManager(DBus::Connection& connection) {} auto -DBusVideoManager::getDeviceList() -> decltype(DRing::getDeviceList()) +DBusVideoManager::getDeviceList() -> decltype(libjami::getDeviceList()) { - return DRing::getDeviceList(); + return libjami::getDeviceList(); } auto -DBusVideoManager::getCapabilities(const std::string& deviceId) -> decltype(DRing::getCapabilities(deviceId)) +DBusVideoManager::getCapabilities(const std::string& deviceId) -> decltype(libjami::getCapabilities(deviceId)) { - return DRing::getCapabilities(deviceId); + return libjami::getCapabilities(deviceId); } auto -DBusVideoManager::getSettings(const std::string& deviceId) -> decltype(DRing::getSettings(deviceId)) +DBusVideoManager::getSettings(const std::string& deviceId) -> decltype(libjami::getSettings(deviceId)) { - return DRing::getSettings(deviceId); + return libjami::getSettings(deviceId); } void DBusVideoManager::applySettings(const std::string& deviceId, const std::map& settings) { - DRing::applySettings(deviceId, settings); + libjami::applySettings(deviceId, settings); } void DBusVideoManager::setDefaultDevice(const std::string& deviceId) { - DRing::setDefaultDevice(deviceId); + libjami::setDefaultDevice(deviceId); } auto -DBusVideoManager::getDefaultDevice() -> decltype(DRing::getDefaultDevice()) +DBusVideoManager::getDefaultDevice() -> decltype(libjami::getDefaultDevice()) { - return DRing::getDefaultDevice(); + return libjami::getDefaultDevice(); } void DBusVideoManager::startAudioDevice() { - DRing::startAudioDevice(); + libjami::startAudioDevice(); } void DBusVideoManager::stopAudioDevice() { - DRing::stopAudioDevice(); + libjami::stopAudioDevice(); } std::string DBusVideoManager::openVideoInput(const std::string& inputUri) { - return DRing::openVideoInput(inputUri); + return libjami::openVideoInput(inputUri); } bool DBusVideoManager::closeVideoInput(const std::string& inputId) { - return DRing::closeVideoInput(inputId); + return libjami::closeVideoInput(inputId); } auto -DBusVideoManager::getDecodingAccelerated() -> decltype(DRing::getDecodingAccelerated()) +DBusVideoManager::getDecodingAccelerated() -> decltype(libjami::getDecodingAccelerated()) { - return DRing::getDecodingAccelerated(); + return libjami::getDecodingAccelerated(); } void DBusVideoManager::setDecodingAccelerated(const bool& state) { - DRing::setDecodingAccelerated(state); + libjami::setDecodingAccelerated(state); } auto -DBusVideoManager::getEncodingAccelerated() -> decltype(DRing::getEncodingAccelerated()) +DBusVideoManager::getEncodingAccelerated() -> decltype(libjami::getEncodingAccelerated()) { - return DRing::getEncodingAccelerated(); + return libjami::getEncodingAccelerated(); } void DBusVideoManager::setEncodingAccelerated(const bool& state) { - DRing::setEncodingAccelerated(state); + libjami::setEncodingAccelerated(state); } void DBusVideoManager::setDeviceOrientation(const std::string& deviceId, const int& angle) { - DRing::setDeviceOrientation(deviceId, angle); + libjami::setDeviceOrientation(deviceId, angle); } void DBusVideoManager::startShmSink(const std::string& sinkId, const bool& value) { - DRing::startShmSink(sinkId, value); + libjami::startShmSink(sinkId, value); } std::map DBusVideoManager::getRenderer(const std::string& callId) { - return DRing::getRenderer(callId); + return libjami::getRenderer(callId); } std::string DBusVideoManager::startLocalMediaRecorder(const std::string& videoInputId, const std::string& filepath) { - return DRing::startLocalMediaRecorder(videoInputId, filepath); + return libjami::startLocalMediaRecorder(videoInputId, filepath); } void DBusVideoManager::stopLocalRecorder(const std::string& filepath) { - DRing::stopLocalRecorder(filepath); + libjami::stopLocalRecorder(filepath); } diff --git a/bin/dbus/dbusvideomanager.h b/bin/dbus/dbusvideomanager.h index 396937d0f..f07d26d50 100644 --- a/bin/dbus/dbusvideomanager.h +++ b/bin/dbus/dbusvideomanager.h @@ -42,7 +42,7 @@ #pragma GCC diagnostic warning "-Wunused-but-set-variable" #endif -class DRING_PUBLIC DBusVideoManager : +class LIBJAMI_PUBLIC DBusVideoManager : public cx::ring::Ring::VideoManager_adaptor, public DBus::IntrospectableAdaptor, public DBus::ObjectAdaptor diff --git a/bin/dbus/main.cpp b/bin/dbus/main.cpp index d0e2f55b6..1a61c29c0 100644 --- a/bin/dbus/main.cpp +++ b/bin/dbus/main.cpp @@ -40,7 +40,7 @@ static void print_title() { std::cout - << "Jami Daemon " << DRing::version() + << "Jami Daemon " << libjami::version() << ", by Savoir-faire Linux 2004-2020" << std::endl << "https://jami.net/" << std::endl #ifdef ENABLE_VIDEO @@ -134,13 +134,13 @@ parse_args(int argc, char *argv[], bool& persistent) } if (consoleFlag) - ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG; + ringFlags |= libjami::LIBJAMI_FLAG_CONSOLE_LOG; if (debugFlag) - ringFlags |= DRing::DRING_FLAG_DEBUG; + ringFlags |= libjami::LIBJAMI_FLAG_DEBUG; if (autoAnswer) - ringFlags |= DRing::DRING_FLAG_AUTOANSWER; + ringFlags |= libjami::LIBJAMI_FLAG_AUTOANSWER; return false; } diff --git a/bin/jni/callmanager.i b/bin/jni/callmanager.i index 0913541d0..31c7581dd 100644 --- a/bin/jni/callmanager.i +++ b/bin/jni/callmanager.i @@ -63,7 +63,7 @@ public: %feature("director") Callback; -namespace DRing { +namespace libjami { /* Call related methods */ std::string placeCallWithMedia(const std::string& accountId, @@ -100,7 +100,7 @@ std::vector getConferenceList(const std::string& accountId); std::vector getParticipantList(const std::string& accountId, const std::string& confId); std::string getConferenceId(const std::string& accountId, const std::string& callId); std::map getConferenceDetails(const std::string& accountId, const std::string& callId); -std::vector currentMediaList(const std::string& accountId, const std::string& callId); +std::vector currentMediaList(const std::string& accountId, const std::string& callId); std::vector> getConferenceInfos(const std::string& accountId, const std::string& confId); void setModerator(const std::string& accountId, const std::string& confId, const std::string& peerId, const bool& state); void muteStream(const std::string& accountId, diff --git a/bin/jni/configurationmanager.i b/bin/jni/configurationmanager.i index 047a035dd..852d80b28 100644 --- a/bin/jni/configurationmanager.i +++ b/bin/jni/configurationmanager.i @@ -71,9 +71,9 @@ public: %} %feature("director") ConfigurationCallback; -%template(MessageVect) std::vector; +%template(MessageVect) std::vector; -namespace DRing { +namespace libjami { struct Message { @@ -94,7 +94,7 @@ std::vector getAccountList(); void sendRegister(const std::string& accountID, bool enable); void registerAllAccounts(void); uint64_t sendAccountTextMessage(const std::string& accountID, const std::string& to, const std::map& message); -std::vector getLastMessages(const std::string& accountID, uint64_t base_timestamp); +std::vector getLastMessages(const std::string& accountID, uint64_t base_timestamp); int getMessageStatus(uint64_t id); int getMessageStatus(const std::string& accountID, uint64_t id); bool cancelMessage(const std::string& accountID, uint64_t id); diff --git a/bin/jni/conversation.i b/bin/jni/conversation.i index 6a628904c..5d2c53841 100644 --- a/bin/jni/conversation.i +++ b/bin/jni/conversation.i @@ -41,7 +41,7 @@ public: %feature("director") ConversationCallback; -namespace DRing { +namespace libjami { // Conversation management std::string startConversation(const std::string& accountId); diff --git a/bin/jni/datatransfer.i b/bin/jni/datatransfer.i index bc861c09f..b24d6f4a4 100644 --- a/bin/jni/datatransfer.i +++ b/bin/jni/datatransfer.i @@ -20,11 +20,11 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -%apply uint32_t { DRing::DataTransferEventCode }; -%apply uint32_t { DRing::DataTransferError }; -%apply uint64_t { DRing::DataTransferId }; -%apply uint64_t { const DRing::DataTransferId }; -%apply int64_t& INOUT { DRing::DataTransferId& id }; +%apply uint32_t { libjami::DataTransferEventCode }; +%apply uint32_t { libjami::DataTransferError }; +%apply uint64_t { libjami::DataTransferId }; +%apply uint64_t { const libjami::DataTransferId }; +%apply int64_t& INOUT { libjami::DataTransferId& id }; %header %{ #include "jami/jami.h" @@ -61,12 +61,12 @@ public: %apply int64_t& OUTPUT { int64_t& total_out } %apply int64_t& OUTPUT { int64_t& progress_out } -namespace DRing { +namespace libjami { struct DataTransferInfo { std::string accountId; - DRing::DataTransferEventCode lastEvent; + libjami::DataTransferEventCode lastEvent; uint32_t flags; int64_t totalSize; int64_t bytesProgress; @@ -80,12 +80,12 @@ namespace DRing { void sendFile(const std::string& accountId, const std::string& conversationId, const std::string& path, const std::string& displayName, const std::string& replyTo); - DRing::DataTransferError sendFileLegacy(const DRing::DataTransferInfo info, DRing::DataTransferId& id); - DRing::DataTransferError acceptFileTransfer(const std::string& accountId, const std::string& fileId, const std::string& file_path); + libjami::DataTransferError sendFileLegacy(const libjami::DataTransferInfo info, libjami::DataTransferId& id); + libjami::DataTransferError acceptFileTransfer(const std::string& accountId, const std::string& fileId, const std::string& file_path); uint64_t downloadFile(const std::string& accountId, const std::string& conversationId, const std::string& interactionId,const std::string& fileId, const std::string& path); - DRing::DataTransferError cancelDataTransfer(const std::string& accountId, const std::string& conversationId, const std::string& fileId); - DRing::DataTransferError dataTransferInfo(const std::string& accountId, const std::string& fileId, DRing::DataTransferInfo &info); - DRing::DataTransferError fileTransferInfo(const std::string& accountId, const std::string& conversationId, const std::string& fileId, std::string &path_out, int64_t &total_out, int64_t &progress_out); + libjami::DataTransferError cancelDataTransfer(const std::string& accountId, const std::string& conversationId, const std::string& fileId); + libjami::DataTransferError dataTransferInfo(const std::string& accountId, const std::string& fileId, libjami::DataTransferInfo &info); + libjami::DataTransferError fileTransferInfo(const std::string& accountId, const std::string& conversationId, const std::string& fileId, std::string &path_out, int64_t &total_out, int64_t &progress_out); } diff --git a/bin/jni/jni_interface.i b/bin/jni/jni_interface.i index 120ec30a5..e9f4d399d 100644 --- a/bin/jni/jni_interface.i +++ b/bin/jni/jni_interface.i @@ -222,16 +222,16 @@ void init(ConfigurationCallback* confM, Callback* callM, PresenceCallback* presM using namespace std::placeholders; using std::bind; - using DRing::exportable_callback; - using DRing::CallSignal; - using DRing::ConfigurationSignal; - using DRing::DataTransferInfo; - using DRing::DataTransferSignal; - using DRing::PresenceSignal; - using DRing::VideoSignal; - using DRing::ConversationSignal; + using libjami::exportable_callback; + using libjami::CallSignal; + using libjami::ConfigurationSignal; + using libjami::DataTransferInfo; + using libjami::DataTransferSignal; + using libjami::PresenceSignal; + using libjami::VideoSignal; + using libjami::ConversationSignal; - using SharedCallback = std::shared_ptr; + using SharedCallback = std::shared_ptr; // Call event handlers const std::map callEvHandlers = { @@ -332,7 +332,7 @@ void init(ConfigurationCallback* confM, Callback* callM, PresenceCallback* presM exportable_callback(bind(&ConversationCallback::conversationPreferencesUpdated, convM, _1, _2, _3)) }; - if (!DRing::init(static_cast(DRing::DRING_FLAG_DEBUG))) + if (!libjami::init(static_cast(libjami::LIBJAMI_FLAG_DEBUG))) return; registerSignalHandlers(callEvHandlers); @@ -342,7 +342,7 @@ void init(ConfigurationCallback* confM, Callback* callM, PresenceCallback* presM registerSignalHandlers(videoEvHandlers); registerSignalHandlers(conversationHandlers); - DRing::start(); + libjami::start(); } diff --git a/bin/jni/managerimpl.i b/bin/jni/managerimpl.i index 78d3c796c..d63436f24 100644 --- a/bin/jni/managerimpl.i +++ b/bin/jni/managerimpl.i @@ -24,7 +24,7 @@ #include "jami/jami.h" %} -namespace DRing { +namespace libjami { /** * Finalizes the daemon, freeing any resource allocated by the library. diff --git a/bin/jni/plugin_manager_interface.i b/bin/jni/plugin_manager_interface.i index dfcc01ca3..09ea559ce 100644 --- a/bin/jni/plugin_manager_interface.i +++ b/bin/jni/plugin_manager_interface.i @@ -23,7 +23,7 @@ #include "jami/plugin_manager_interface.h" %} -namespace DRing { +namespace libjami { bool loadPlugin(const std::string& path); bool unloadPlugin(const std::string& path); std::map getPluginDetails(const std::string& path); diff --git a/bin/jni/presencemanager.i b/bin/jni/presencemanager.i index 284cbe93a..ae015b638 100644 --- a/bin/jni/presencemanager.i +++ b/bin/jni/presencemanager.i @@ -35,7 +35,7 @@ public: %feature("director") PresenceCallback; -namespace DRing { +namespace libjami { /* Presence subscription/Notification. */ void publish(const std::string& accountID, bool status, const std::string& note); diff --git a/bin/jni/videomanager.i b/bin/jni/videomanager.i index 6fdb6584d..9f5451b42 100644 --- a/bin/jni/videomanager.i +++ b/bin/jni/videomanager.i @@ -57,7 +57,7 @@ public: %{ -std::map windows {}; +std::map windows {}; std::mutex windows_mutex; std::vector workspace; @@ -156,7 +156,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_captureVideoPacket(JN if (!inputId_pstr) return; std::string_view input(inputId_pstr); - auto frame = DRing::getNewFrame(input); + auto frame = libjami::getNewFrame(input); if (not frame) return; auto packet = std::unique_ptr(av_packet_alloc(), [](AVPacket* pkt){ @@ -174,7 +174,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_captureVideoPacket(JN packet->size = size; packet->pts = timestamp; frame->setPacket(std::move(packet)); - DRing::publishFrame(input); + libjami::publishFrame(input); } catch (const std::exception& e) { __android_log_print(ANDROID_LOG_ERROR, TAG, "Exception capturing video packet: %s", e.what()); } @@ -200,7 +200,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_captureVideoFrame(JNI return; std::string_view input(inputId_pstr); - auto frame = DRing::getNewFrame(input); + auto frame = libjami::getNewFrame(input); if (not frame) { jenv->CallVoidMethod(image, imageClose); return; @@ -286,7 +286,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_captureVideoFrame(JNI if (justAttached) gJavaVM->DetachCurrentThread(); }); - DRing::publishFrame(input); + libjami::publishFrame(input); jenv->ReleaseStringUTFChars(inputId, inputId_pstr); } catch (const std::exception& e) { __android_log_print(ANDROID_LOG_ERROR, TAG, "Exception capturing video frame: %s", e.what()); @@ -310,7 +310,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_setNativeWindowGeomet ANativeWindow_setBuffersGeometry(window, width, height, WINDOW_FORMAT_RGBX_8888); } -void releaseBuffer(ANativeWindow *window, DRing::FrameBuffer frame) +void releaseBuffer(ANativeWindow *window, libjami::FrameBuffer frame) { std::unique_lock guard(windows_mutex); try { @@ -320,16 +320,16 @@ void releaseBuffer(ANativeWindow *window, DRing::FrameBuffer frame) } } -void AndroidDisplayCb(ANativeWindow *window, DRing::FrameBuffer frame) +void AndroidDisplayCb(ANativeWindow *window, libjami::FrameBuffer frame) { ANativeWindow_unlockAndPost(window); releaseBuffer(window, std::move(frame)); } -DRing::FrameBuffer sinkTargetPullCallback(ANativeWindow *window) +libjami::FrameBuffer sinkTargetPullCallback(ANativeWindow *window) { try { - DRing::FrameBuffer frame; + libjami::FrameBuffer frame; { std::lock_guard guard(windows_mutex); frame = std::move(windows.at(window)); @@ -372,9 +372,9 @@ JNIEXPORT jboolean JNICALL Java_net_jami_daemon_JamiServiceJNI_registerVideoCall { std::lock_guard guard(windows_mutex); - windows.emplace(nativeWindow, DRing::FrameBuffer{av_frame_alloc()}); + windows.emplace(nativeWindow, libjami::FrameBuffer{av_frame_alloc()}); } - return DRing::registerSinkTarget(sink, DRing::SinkTarget {.pull=p_display_cb, .push=f_display_cb}) ? JNI_TRUE : JNI_FALSE; + return libjami::registerSinkTarget(sink, libjami::SinkTarget {.pull=p_display_cb, .push=f_display_cb}) ? JNI_TRUE : JNI_FALSE; } JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_unregisterVideoCallback(JNIEnv *jenv, jclass jcls, jstring sinkId, jlong window) @@ -390,7 +390,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_unregisterVideoCallba jenv->ReleaseStringUTFChars(sinkId, arg1_pstr); ANativeWindow* nativeWindow = (ANativeWindow*)((intptr_t) window); - DRing::registerSinkTarget(sink, DRing::SinkTarget {}); + libjami::registerSinkTarget(sink, libjami::SinkTarget {}); std::lock_guard guard(windows_mutex); windows.erase(nativeWindow); @@ -407,7 +407,7 @@ JNIEXPORT void JNICALL Java_net_jami_daemon_JamiServiceJNI_unregisterVideoCallba %native(captureVideoFrame) void captureVideoFrame(jstring, jobject, jint); %native(captureVideoPacket) void captureVideoPacket(jstring, jobject, jint, jint, jboolean, jlong, jint); -namespace DRing { +namespace libjami { void setDefaultDevice(const std::string& name); std::string getDefaultDevice(); @@ -420,7 +420,7 @@ void applySettings(const std::string& name, const std::map getConferenceList(const std::string& accountId); std::vector getParticipantList(const std::string& accountId, const std::string& confId); std::string getConferenceId(const std::string& accountId, const std::string& callId); std::map getConferenceDetails(const std::string& accountId, const std::string& callId); -std::vector currentMediaList(const std::string& accountId, const std::string& callId); +std::vector currentMediaList(const std::string& accountId, const std::string& callId); std::vector> getConferenceInfos(const std::string& accountId, const std::string& confId); void setModerator(const std::string& accountId, const std::string& confId, const std::string& peerId, const bool& state); void muteStream(const std::string& accountId, diff --git a/bin/nodejs/configurationmanager.i b/bin/nodejs/configurationmanager.i index 94b9f3ce5..b9a422dca 100644 --- a/bin/nodejs/configurationmanager.i +++ b/bin/nodejs/configurationmanager.i @@ -68,7 +68,7 @@ public: %feature("director") ConfigurationCallback; -namespace DRing { +namespace libjami { struct Message { diff --git a/bin/nodejs/conversation.i b/bin/nodejs/conversation.i index ac254bcd2..fc99c55a1 100644 --- a/bin/nodejs/conversation.i +++ b/bin/nodejs/conversation.i @@ -41,7 +41,7 @@ public: %feature("director") ConversationCallback; -namespace DRing { +namespace libjami { // Conversation management std::string startConversation(const std::string& accountId); diff --git a/bin/nodejs/managerimpl.i b/bin/nodejs/managerimpl.i index 2bbc6e616..99694e5d4 100644 --- a/bin/nodejs/managerimpl.i +++ b/bin/nodejs/managerimpl.i @@ -24,7 +24,7 @@ #include "jami/jami.h" %} -namespace DRing { +namespace libjami { /** * Finalizes libsflphone, freeing any resource allocated by the library. diff --git a/bin/nodejs/nodejs_interface.i b/bin/nodejs/nodejs_interface.i index bacb5dddb..1acb741cd 100644 --- a/bin/nodejs/nodejs_interface.i +++ b/bin/nodejs/nodejs_interface.i @@ -114,11 +114,11 @@ void init(const SWIGV8_VALUE& funcMap){ using namespace std::placeholders; using std::bind; - using DRing::exportable_callback; - using DRing::ConfigurationSignal; - using DRing::CallSignal; - using DRing::ConversationSignal; - using SharedCallback = std::shared_ptr; + using libjami::exportable_callback; + using libjami::ConfigurationSignal; + using libjami::CallSignal; + using libjami::ConversationSignal; + using SharedCallback = std::shared_ptr; const std::map callEvHandlers = { exportable_callback(bind(&callStateChanged, _1, _2, _3, _4)), exportable_callback(bind(&incomingMessage, _1, _2, _3, _4)), @@ -160,14 +160,14 @@ void init(const SWIGV8_VALUE& funcMap){ exportable_callback(bind(&conversationPreferencesUpdated, _1, _2, _3)) }; - if (!DRing::init(static_cast(DRing::DRING_FLAG_DEBUG))) + if (!libjami::init(static_cast(libjami::LIBJAMI_FLAG_DEBUG))) return; registerSignalHandlers(configEvHandlers); registerSignalHandlers(callEvHandlers); registerSignalHandlers(conversationHandlers); - DRing::start(); + libjami::start(); } %} #ifndef SWIG diff --git a/bin/nodejs/presencemanager.i b/bin/nodejs/presencemanager.i index 284cbe93a..ae015b638 100644 --- a/bin/nodejs/presencemanager.i +++ b/bin/nodejs/presencemanager.i @@ -35,7 +35,7 @@ public: %feature("director") PresenceCallback; -namespace DRing { +namespace libjami { /* Presence subscription/Notification. */ void publish(const std::string& accountID, bool status, const std::string& note); diff --git a/bin/nodejs/videomanager.i b/bin/nodejs/videomanager.i index 57704b5a2..3cb42bdb9 100644 --- a/bin/nodejs/videomanager.i +++ b/bin/nodejs/videomanager.i @@ -41,7 +41,7 @@ public: %feature("director") VideoCallback; -namespace DRing { +namespace libjami { void setDefaultDevice(const std::string& name); std::string getDefaultDevice(); @@ -51,7 +51,7 @@ void stopAudioDevice(); std::map getSettings(const std::string& name); void applySettings(const std::string& name, const std::map& settings); -void registerSinkTarget(const std::string& sinkId, const DRing::SinkTarget& target); +void registerSinkTarget(const std::string& sinkId, const libjami::SinkTarget& target); bool getDecodingAccelerated(); void setDecodingAccelerated(bool state); bool getEncodingAccelerated(); diff --git a/bin/osxmain.cpp b/bin/osxmain.cpp index f72dbddaa..fbefaf055 100644 --- a/bin/osxmain.cpp +++ b/bin/osxmain.cpp @@ -42,7 +42,7 @@ static void print_title() { std::cout - << "Jami Daemon " << DRing::version() + << "Jami Daemon " << libjami::version() << ", by Savoir-faire Linux 2004-2019" << std::endl << "https://jami.net/" << std::endl #ifdef ENABLE_VIDEO @@ -136,13 +136,13 @@ parse_args(int argc, char *argv[], bool& persistent) } if (consoleFlag) - ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG; + ringFlags |= libjami::LIBJAMI_FLAG_CONSOLE_LOG; if (debugFlag) - ringFlags |= DRing::DRING_FLAG_DEBUG; + ringFlags |= libjami::LIBJAMI_FLAG_DEBUG; if (autoAnswer) - ringFlags |= DRing::DRING_FLAG_AUTOANSWER; + ringFlags |= libjami::LIBJAMI_FLAG_AUTOANSWER; return false; } @@ -150,20 +150,20 @@ parse_args(int argc, char *argv[], bool& persistent) static int osxTests() { - using SharedCallback = std::shared_ptr; + using SharedCallback = std::shared_ptr; - DRing::init(static_cast(ringFlags)); + libjami::init(static_cast(ringFlags)); - registerSignalHandlers(std::map>()); + registerSignalHandlers(std::map>()); - if (!DRing::start()) + if (!libjami::start()) return -1; while (true) { std::this_thread::sleep_for(std::chrono::seconds(1)); } - DRing::fini(); + libjami::fini(); } static int diff --git a/bin/winmain.cpp b/bin/winmain.cpp index f35cf958c..edf31dc93 100644 --- a/bin/winmain.cpp +++ b/bin/winmain.cpp @@ -46,7 +46,7 @@ static void print_title() { std::cout - << "Jami Daemon " << DRing::version() + << "Jami Daemon " << libjami::version() << ", by Savoir-faire Linux 2004-2019" << std::endl << "https://jami.net/" << std::endl #ifdef ENABLE_VIDEO @@ -140,13 +140,13 @@ parse_args(int argc, char *argv[], bool& persistent) } if (consoleFlag) - ringFlags |= DRing::DRING_FLAG_CONSOLE_LOG; + ringFlags |= libjami::LIBJAMI_FLAG_CONSOLE_LOG; if (debugFlag) - ringFlags |= DRing::DRING_FLAG_DEBUG; + ringFlags |= libjami::LIBJAMI_FLAG_DEBUG; if (autoAnswer) - ringFlags |= DRing::DRING_FLAG_AUTOANSWER; + ringFlags |= libjami::LIBJAMI_FLAG_AUTOANSWER; return false; } @@ -158,33 +158,33 @@ IncomingCall(const std::string& accountId, (void) accountId; (void) message; if (not isActive) { - DRing::accept(callId); + libjami::accept(callId); isActive = true; } else - DRing::refuse(callId); + libjami::refuse(callId); } static int run() { - using SharedCallback = std::shared_ptr; + using SharedCallback = std::shared_ptr; - DRing::init(static_cast(ringFlags)); + libjami::init(static_cast(ringFlags)); std::map callHandlers; - callHandlers.insert(DRing::exportable_callback + callHandlers.insert(libjami::exportable_callback (std::bind(&IncomingCall, _1, _2, _3))); registerSignalHandlers(callHandlers); - if (!DRing::start()) + if (!libjami::start()) return -1; while (loop) { Sleep(1000); // milliseconds } - DRing::fini(); + libjami::fini(); return 0; } diff --git a/configure.ac b/configure.ac index 27215d044..8a38e4342 100644 --- a/configure.ac +++ b/configure.ac @@ -217,10 +217,10 @@ AC_COMPILE_IFELSE( AC_MSG_RESULT([$CLANG]) -dnl define DRING_BUILD because we are building libjami, not using it +dnl define LIBJAMI_BUILD because we are building libjami, not using it dnl if building shared library, define jami_EXPORTS AC_MSG_CHECKING([if compiling shared library]) -DAEMONCPPFLAGS+=" -fvisibility=hidden -DDRING_BUILD" +DAEMONCPPFLAGS+=" -fvisibility=hidden -DLIBJAMI_BUILD" AS_IF([test "x$enable_shared" == "xyes"], [RING_SHARED=yes DAEMONCPPFLAGS+=" -Djami_EXPORTS"], diff --git a/globals.mk b/globals.mk index f30c7f45a..27156f734 100644 --- a/globals.mk +++ b/globals.mk @@ -17,7 +17,7 @@ AM_CPPFLAGS += \ -DPREFIX=\"$(prefix)\" \ -DJAMI_DATADIR=\"$(JAMI_DATADIR)\" \ -DENABLE_TRACE \ - -DRING_REVISION=\"$(RING_REVISION)\" \ - -DRING_DIRTY_REPO=\"$(RING_DIRTY_REPO)\" \ + -LIBJAMI_REVISION=\"$(RING_REVISION)\" \ + -LIBJAMI_DIRTY_REPO=\"$(RING_DIRTY_REPO)\" \ -DPJSIP_MAX_PKT_LEN=8000 \ -DPJ_AUTOCONF=1 diff --git a/meson.build b/meson.build index 3312907c3..211acff63 100644 --- a/meson.build +++ b/meson.build @@ -153,7 +153,7 @@ add_project_arguments('-DHAVE_CONFIG_H', language: 'c') ################################################# # Build targets ################################################# -add_project_arguments('-DRING_BUILD', language: ['c', 'cpp']) +add_project_arguments('-LIBJAMI_BUILD', language: ['c', 'cpp']) if get_option('default_library') != 'static' add_project_arguments('-Djami_EXPORTS', language: ['c', 'cpp']) endif diff --git a/src/account.cpp b/src/account.cpp index 088cb452b..ba025d854 100644 --- a/src/account.cpp +++ b/src/account.cpp @@ -176,12 +176,12 @@ Account::setRegistrationState(RegistrationState state, detail_code, detail_str, details = getVolatileAccountDetails()] { - emitSignal(accountId, + emitSignal(accountId, state, detail_code, detail_str); - emitSignal(accountId, details); + emitSignal(accountId, details); }); } } @@ -319,7 +319,7 @@ Account::setAccountDetails(const std::map& details) parseBool(details, Conf::CONFIG_ACCOUNT_AUTOANSWER, autoAnswerEnabled_); parseBool(details, Conf::CONFIG_ACCOUNT_SENDREADRECEIPT, sendReadReceipt_); parseBool(details, Conf::CONFIG_ACCOUNT_ISRENDEZVOUS, isRendezVous_); - parseInt(details, DRing::Account::ConfProperties::ACTIVE_CALL_LIMIT, activeCallLimit_); + parseInt(details, libjami::Account::ConfProperties::ACTIVE_CALL_LIMIT, activeCallLimit_); parseBool(details, Conf::CONFIG_RINGTONE_ENABLED, ringtoneEnabled_); parseString(details, Conf::CONFIG_RINGTONE_PATH, ringtonePath_); if (ringtonePath_.empty()) { @@ -354,7 +354,7 @@ Account::getAccountDetails() const {Conf::CONFIG_ACCOUNT_AUTOANSWER, autoAnswerEnabled_ ? TRUE_STR : FALSE_STR}, {Conf::CONFIG_ACCOUNT_SENDREADRECEIPT, sendReadReceipt_ ? TRUE_STR : FALSE_STR}, {Conf::CONFIG_ACCOUNT_ISRENDEZVOUS, isRendezVous_ ? TRUE_STR : FALSE_STR}, - {DRing::Account::ConfProperties::ACTIVE_CALL_LIMIT, std::to_string(activeCallLimit_)}, + {libjami::Account::ConfProperties::ACTIVE_CALL_LIMIT, std::to_string(activeCallLimit_)}, {Conf::CONFIG_RINGTONE_ENABLED, ringtoneEnabled_ ? TRUE_STR : FALSE_STR}, {Conf::CONFIG_RINGTONE_PATH, ringtonePath_}, {Conf::CONFIG_UPNP_ENABLED, upnpEnabled_ ? TRUE_STR : FALSE_STR}, @@ -367,7 +367,7 @@ std::map Account::getVolatileAccountDetails() const { return {{Conf::CONFIG_ACCOUNT_REGISTRATION_STATUS, mapStateNumberToString(registrationState_)}, - {DRing::Account::VolatileProperties::ACTIVE, active_ ? TRUE_STR : FALSE_STR}}; + {libjami::Account::VolatileProperties::ACTIVE, active_ ? TRUE_STR : FALSE_STR}}; } bool @@ -461,7 +461,7 @@ Account::mapStateNumberToString(RegistrationState state) CASE_STATE(ERROR_NEED_MIGRATION); CASE_STATE(INITIALIZING); default: - return DRing::Account::States::ERROR_GENERIC; + return libjami::Account::States::ERROR_GENERIC; } #undef CASE_STATE @@ -682,9 +682,9 @@ Account::setDefaultUserAgent() std::string defaultUA; defaultUA.append(PACKAGE_NAME); defaultUA.append(" "); - defaultUA.append(DRing::version()); + defaultUA.append(libjami::version()); defaultUA.append(" ("); - defaultUA.append(DRing::platform()); + defaultUA.append(libjami::platform()); defaultUA.append(")"); return defaultUA; diff --git a/src/account.h b/src/account.h index 6911100af..f7b3c24df 100644 --- a/src/account.h +++ b/src/account.h @@ -155,7 +155,7 @@ public: * @return The created call */ virtual std::shared_ptr newOutgoingCall(std::string_view toUrl, - const std::vector& mediaList) + const std::vector& mediaList) = 0; /** @@ -178,7 +178,7 @@ public: return false; }; - virtual std::vector getLastMessages(const uint64_t& /*base_timestamp*/) + virtual std::vector getLastMessages(const uint64_t& /*base_timestamp*/) { return {}; } @@ -393,7 +393,7 @@ public: { auto result = callSet_.removeConference(confId); if (result) - emitSignal(getAccountID(), confId); + emitSignal(getAccountID(), confId); return result; } diff --git a/src/archiver.cpp b/src/archiver.cpp index 472bb91de..b32f52037 100644 --- a/src/archiver.cpp +++ b/src/archiver.cpp @@ -60,20 +60,20 @@ jsonValueToAccount(Json::Value& value, const std::string& accountId) { auto idPath_ = fileutils::get_data_dir() + DIR_SEPARATOR_STR + accountId; fileutils::check_dir(idPath_.c_str(), 0700); - auto detailsMap = DRing::getAccountTemplate( - value[DRing::Account::ConfProperties::TYPE].asString()); + auto detailsMap = libjami::getAccountTemplate( + value[libjami::Account::ConfProperties::TYPE].asString()); for (Json::ValueIterator itr = value.begin(); itr != value.end(); itr++) { if (itr->asString().empty()) continue; - if (itr.key().asString().compare(DRing::Account::ConfProperties::TLS::CA_LIST_FILE) == 0) { + if (itr.key().asString().compare(libjami::Account::ConfProperties::TLS::CA_LIST_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "ca.key", {fileContent.begin(), fileContent.end()}, 0600); } else if (itr.key().asString().compare( - DRing::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) + libjami::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "dht.key", @@ -81,7 +81,7 @@ jsonValueToAccount(Json::Value& value, const std::string& accountId) 0600); } else if (itr.key().asString().compare( - DRing::Account::ConfProperties::TLS::CERTIFICATE_FILE) + libjami::Account::ConfProperties::TLS::CERTIFICATE_FILE) == 0) { std::string fileContent(itr->asString()); fileutils::saveFile(idPath_ + DIR_SEPARATOR_STR "dht.crt", @@ -99,11 +99,11 @@ accountToJsonValue(const std::map& details) { Json::Value root; for (const auto& i : details) { - if (i.first == DRing::Account::ConfProperties::Ringtone::PATH) { + if (i.first == libjami::Account::ConfProperties::Ringtone::PATH) { // Ringtone path is not exportable - } else if (i.first == DRing::Account::ConfProperties::TLS::CA_LIST_FILE - || i.first == DRing::Account::ConfProperties::TLS::CERTIFICATE_FILE - || i.first == DRing::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) { + } else if (i.first == libjami::Account::ConfProperties::TLS::CA_LIST_FILE + || i.first == libjami::Account::ConfProperties::TLS::CERTIFICATE_FILE + || i.first == libjami::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) { // replace paths by the files content std::ifstream ifs = fileutils::ifstream(i.second); std::string fileContent((std::istreambuf_iterator(ifs)), diff --git a/src/buildinfo.cpp b/src/buildinfo.cpp index 57ec55093..f10eb8e1c 100644 --- a/src/buildinfo.cpp +++ b/src/buildinfo.cpp @@ -39,7 +39,7 @@ #define PACKAGE_VERSION "unknown" #endif -namespace DRing { +namespace libjami { const char* version() noexcept @@ -70,4 +70,4 @@ platform() noexcept #error "Unknown OS" #endif } -} // namespace DRing +} // namespace libjami diff --git a/src/call.cpp b/src/call.cpp index ffc3a2757..88262f1d1 100644 --- a/src/call.cpp +++ b/src/call.cpp @@ -275,7 +275,7 @@ Call::setState(CallState call_state, ConnectionState cnx_state, signed code) new_client_state.c_str(), code); lock.unlock(); - emitSignal(getAccountId(), id_, new_client_state, code); + emitSignal(getAccountId(), id_, new_client_state, code); } } @@ -299,7 +299,7 @@ Call::setState(ConnectionState cnx_state, signed code) std::string Call::getStateStr() const { - using namespace DRing::Call; + using namespace libjami::Call; switch (getState()) { case CallState::ACTIVE: @@ -363,7 +363,7 @@ Call::toggleRecording() void Call::updateDetails(const std::map& details) { - const auto& iter = details.find(DRing::Call::Details::AUDIO_ONLY); + const auto& iter = details.find(libjami::Call::Details::AUDIO_ONLY); if (iter != std::end(details)) isAudioOnly_ = iter->second == TRUE_STR; } @@ -373,18 +373,18 @@ Call::getDetails() const { auto conference = conf_.lock(); return { - {DRing::Call::Details::CALL_TYPE, std::to_string((unsigned) type_)}, - {DRing::Call::Details::PEER_NUMBER, peerNumber_}, - {DRing::Call::Details::DISPLAY_NAME, peerDisplayName_}, - {DRing::Call::Details::CALL_STATE, getStateStr()}, - {DRing::Call::Details::CONF_ID, conference ? conference->getConfId() : ""}, - {DRing::Call::Details::TIMESTAMP_START, std::to_string(timestamp_start_)}, - {DRing::Call::Details::ACCOUNTID, getAccountId()}, - {DRing::Call::Details::AUDIO_MUTED, + {libjami::Call::Details::CALL_TYPE, std::to_string((unsigned) type_)}, + {libjami::Call::Details::PEER_NUMBER, peerNumber_}, + {libjami::Call::Details::DISPLAY_NAME, peerDisplayName_}, + {libjami::Call::Details::CALL_STATE, getStateStr()}, + {libjami::Call::Details::CONF_ID, conference ? conference->getConfId() : ""}, + {libjami::Call::Details::TIMESTAMP_START, std::to_string(timestamp_start_)}, + {libjami::Call::Details::ACCOUNTID, getAccountId()}, + {libjami::Call::Details::AUDIO_MUTED, std::string(bool_to_str(isCaptureDeviceMuted(MediaType::MEDIA_AUDIO)))}, - {DRing::Call::Details::VIDEO_MUTED, + {libjami::Call::Details::VIDEO_MUTED, std::string(bool_to_str(isCaptureDeviceMuted(MediaType::MEDIA_VIDEO)))}, - {DRing::Call::Details::AUDIO_ONLY, std::string(bool_to_str(not hasVideo()))}, + {libjami::Call::Details::AUDIO_ONLY, std::string(bool_to_str(not hasVideo()))}, }; } @@ -591,7 +591,7 @@ Call::checkPendingIM() auto state = getStateStr(); // Let parent call handles IM after the merge if (not parent_) { - if (state == DRing::Call::StateEvent::CURRENT) { + if (state == libjami::Call::StateEvent::CURRENT) { for (const auto& msg : pendingInMessages_) Manager::instance().incomingMessage(getAccountId(), getCallId(), @@ -614,7 +614,7 @@ Call::checkPendingIM() void Call::checkAudio() { - using namespace DRing::Call; + using namespace libjami::Call; auto state = getStateStr(); if (state == StateEvent::RINGING) { @@ -686,7 +686,7 @@ Call::setConferenceInfo(const std::string& msg) createSinks(confInfo_); #endif // Inform client that layout has changed - jami::emitSignal( + jami::emitSignal( id_, confInfo_.toVectorMapStringString()); } else if (auto conf = conf_.lock()) { conf->mergeConfInfo(newInfo, getPeerNumber()); diff --git a/src/call.h b/src/call.h index 1bd5512ae..8351a20e4 100644 --- a/src/call.h +++ b/src/call.h @@ -225,7 +225,7 @@ public: * If the media list is empty, the current media set when the call * was created will be used. */ - virtual void answer(const std::vector& mediaList) = 0; + virtual void answer(const std::vector& mediaList) = 0; /** * Check the media of an incoming media change request. @@ -241,14 +241,14 @@ public: * @param the new media list from the remote * @return true if the new media differs from the current media **/ - virtual bool checkMediaChangeRequest(const std::vector& remoteMediaList) = 0; + virtual bool checkMediaChangeRequest(const std::vector& remoteMediaList) = 0; /** * Process incoming media change request. * * @param the new media list from the remote */ - virtual void handleMediaChangeRequest(const std::vector& remoteMediaList) = 0; + virtual void handleMediaChangeRequest(const std::vector& remoteMediaList) = 0; /** * Answer to a media update request. @@ -261,7 +261,7 @@ public: * to determine wether an answer will be sent to the peer. * @param isRemote True if the media list is from the remote peer */ - virtual void answerMediaChangeRequest(const std::vector& mediaList, + virtual void answerMediaChangeRequest(const std::vector& mediaList, bool isRemote = false) = 0; /** @@ -383,13 +383,13 @@ public: * @param mediaList the new media list * @return true on success */ - virtual bool requestMediaChange(const std::vector& mediaList) = 0; + virtual bool requestMediaChange(const std::vector& mediaList) = 0; /** * Retrieve current medias list * @return current medias */ - virtual std::vector currentMediaList() const = 0; + virtual std::vector currentMediaList() const = 0; /** * Send a message to a call identified by its callid diff --git a/src/call_factory.cpp b/src/call_factory.cpp index 3e77297dd..123c34384 100644 --- a/src/call_factory.cpp +++ b/src/call_factory.cpp @@ -42,7 +42,7 @@ CallFactory::getNewCallID() const std::shared_ptr CallFactory::newSipCall(const std::shared_ptr& account, Call::CallType type, - const std::vector& mediaList) + const std::vector& mediaList) { if (not allowNewCall_) { JAMI_WARN("Creation of new calls is not allowed"); diff --git a/src/call_factory.h b/src/call_factory.h index 041fdadff..87f12caf3 100644 --- a/src/call_factory.h +++ b/src/call_factory.h @@ -53,7 +53,7 @@ public: */ std::shared_ptr newSipCall(const std::shared_ptr& account, Call::CallType type, - const std::vector& mediaList); + const std::vector& mediaList); /** * Forbid creation of new calls. diff --git a/src/client/callmanager.cpp b/src/client/callmanager.cpp index 4947be444..a336fde4f 100644 --- a/src/client/callmanager.cpp +++ b/src/client/callmanager.cpp @@ -39,7 +39,7 @@ #include "smartools.h" -namespace DRing { +namespace libjami { void registerCallHandlers(const std::map>& handlers) @@ -58,7 +58,7 @@ placeCall(const std::string& accountId, const std::string& to) std::string placeCallWithMedia(const std::string& accountId, const std::string& to, - const std::vector& mediaList) + const std::vector& mediaList) { // Check if a destination number is available if (to.empty()) { @@ -72,7 +72,7 @@ placeCallWithMedia(const std::string& accountId, bool requestMediaChange(const std::string& accountId, const std::string& callId, - const std::vector& mediaList) + const std::vector& mediaList) { if (auto account = jami::Manager::instance().getAccount(accountId)) { if (auto call = account->getCall(callId)) { @@ -99,7 +99,7 @@ accept(const std::string& accountId, const std::string& callId) bool acceptWithMedia(const std::string& accountId, const std::string& callId, - const std::vector& mediaList) + const std::vector& mediaList) { return jami::Manager::instance().answerCall(accountId, callId, mediaList); } @@ -107,7 +107,7 @@ acceptWithMedia(const std::string& accountId, bool answerMediaChangeRequest(const std::string& accountId, const std::string& callId, - const std::vector& mediaList) + const std::vector& mediaList) { if (auto account = jami::Manager::instance().getAccount(accountId)) if (auto call = account->getCall(callId)) { @@ -278,7 +278,7 @@ holdConference(const std::string& accountId, const std::string& confId) if (const auto account = jami::Manager::instance().getAccount(accountId)) if (auto conf = account->getConference(confId)) { conf->detach(); - jami::emitSignal(conf->getConfId(), + jami::emitSignal(conf->getConfId(), conf->getStateStr()); return true; } return false;*/ @@ -704,4 +704,4 @@ raiseHand(const std::string& accountId, } } -} // namespace DRing +} // namespace libjami diff --git a/src/client/configurationmanager.cpp b/src/client/configurationmanager.cpp index 4e28fa851..00370cbbe 100644 --- a/src/client/configurationmanager.cpp +++ b/src/client/configurationmanager.cpp @@ -62,7 +62,7 @@ #undef interface #endif -namespace DRing { +namespace libjami { constexpr unsigned CODECS_NOT_LOADED = 0x1000; /** Codecs not found */ @@ -953,7 +953,7 @@ lookupName(const std::string& account, const std::string& nameserver, const std: #if HAVE_RINGNS if (account.empty()) { auto cb = [name](const std::string& result, jami::NameDirectory::Response response) { - jami::emitSignal("", + jami::emitSignal("", (int) response, result, name); @@ -980,7 +980,7 @@ lookupAddress(const std::string& account, const std::string& nameserver, const s .lookupAddress(address, [address](const std::string& result, jami::NameDirectory::Response response) { - jami::emitSignal( + jami::emitSignal( "", (int) response, address, result); }); return true; @@ -1097,4 +1097,4 @@ isAllModerators(const std::string& accountID) return jami::Manager::instance().isAllModerators(accountID); } -} // namespace DRing +} // namespace libjami diff --git a/src/client/conversation_interface.cpp b/src/client/conversation_interface.cpp index 7312f3f2d..d46952c8b 100644 --- a/src/client/conversation_interface.cpp +++ b/src/client/conversation_interface.cpp @@ -33,7 +33,7 @@ #include "jamidht/jamiaccount.h" #include "jamidht/conversation_module.h" -namespace DRing { +namespace libjami { std::string startConversation(const std::string& accountId) @@ -236,4 +236,4 @@ searchConversation(const std::string& accountId, return res; } -} // namespace DRing +} // namespace libjami diff --git a/src/client/datatransfer.cpp b/src/client/datatransfer.cpp index 3adbbc059..a5ed206a7 100644 --- a/src/client/datatransfer.cpp +++ b/src/client/datatransfer.cpp @@ -25,7 +25,7 @@ #include "client/ring_signal.h" #include "jamidht/jamiaccount.h" -namespace DRing { +namespace libjami { void registerDataXferHandlers(const std::map>& handlers) @@ -38,10 +38,10 @@ sendFileLegacy(const DataTransferInfo& info, DataTransferId& tid) noexcept { if (auto acc = jami::Manager::instance().getAccount(info.accountId)) { tid = acc->sendFile(info.peer, info.path); - return DRing::DataTransferError::success; + return libjami::DataTransferError::success; } - return DRing::DataTransferError::invalid_argument; + return libjami::DataTransferError::invalid_argument; } void @@ -65,14 +65,14 @@ acceptFileTransfer(const std::string& accountId, if (auto dt = acc->dataTransfer()) { try { return dt->acceptFile(std::stoull(fileId), file_path) - ? DRing::DataTransferError::success - : DRing::DataTransferError::invalid_argument; + ? libjami::DataTransferError::success + : libjami::DataTransferError::invalid_argument; } catch (...) { JAMI_ERR() << "Invalid file Id" << fileId; } } } - return DRing::DataTransferError::invalid_argument; + return libjami::DataTransferError::invalid_argument; } bool @@ -95,10 +95,10 @@ cancelDataTransfer(const std::string& accountId, { if (auto acc = jami::Manager::instance().getAccount(accountId)) { if (auto dt = acc->dataTransfer(conversationId)) - return dt->cancel(fileId) ? DRing::DataTransferError::success - : DRing::DataTransferError::invalid_argument; + return dt->cancel(fileId) ? libjami::DataTransferError::success + : libjami::DataTransferError::invalid_argument; } - return DRing::DataTransferError::invalid_argument; + return libjami::DataTransferError::invalid_argument; } DataTransferError @@ -112,10 +112,10 @@ fileTransferInfo(const std::string& accountId, if (auto acc = jami::Manager::instance().getAccount(accountId)) { if (auto dt = acc->dataTransfer(conversationId)) return dt->info(fileId, path, total, progress) - ? DRing::DataTransferError::success - : DRing::DataTransferError::invalid_argument; + ? libjami::DataTransferError::success + : libjami::DataTransferError::invalid_argument; } - return DRing::DataTransferError::invalid_argument; + return libjami::DataTransferError::invalid_argument; } DataTransferError @@ -127,14 +127,14 @@ dataTransferInfo(const std::string& accountId, if (auto dt = acc->dataTransfer()) { try { return dt->info(std::stoull(fileId), info) - ? DRing::DataTransferError::success - : DRing::DataTransferError::invalid_argument; + ? libjami::DataTransferError::success + : libjami::DataTransferError::invalid_argument; } catch (...) { JAMI_ERR() << "Invalid fileId: " << fileId; } } } - return DRing::DataTransferError::invalid_argument; + return libjami::DataTransferError::invalid_argument; } -} // namespace DRing +} // namespace libjami diff --git a/src/client/plugin_manager_interface.cpp b/src/client/plugin_manager_interface.cpp index 9ccdb5179..e5c148c33 100644 --- a/src/client/plugin_manager_interface.cpp +++ b/src/client/plugin_manager_interface.cpp @@ -24,7 +24,7 @@ #include "logger.h" #include -namespace DRing { +namespace libjami { bool loadPlugin(const std::string& path) { @@ -236,4 +236,4 @@ sendWebViewDetach(const std::string& pluginId, const std::string& webViewId) .getWebViewServicesManager() .sendWebViewDetach(pluginId, webViewId); } -} // namespace DRing +} // namespace libjami diff --git a/src/client/presencemanager.cpp b/src/client/presencemanager.cpp index e3d97e2fe..d3b729464 100644 --- a/src/client/presencemanager.cpp +++ b/src/client/presencemanager.cpp @@ -40,7 +40,7 @@ #include "jamidht/jamiaccount.h" -namespace DRing { +namespace libjami { using jami::SIPAccount; @@ -128,9 +128,9 @@ getSubscriptions(const std::string& accountID) ret.reserve(subs.size()); for (const auto& s : subs) { ret.push_back( - {{DRing::Presence::BUDDY_KEY, std::string(s->getURI())}, - {DRing::Presence::STATUS_KEY, s->isPresent() ? DRing::Presence::ONLINE_KEY : DRing::Presence::OFFLINE_KEY}, - {DRing::Presence::LINESTATUS_KEY, std::string(s->getLineStatus())}}); + {{libjami::Presence::BUDDY_KEY, std::string(s->getURI())}, + {libjami::Presence::STATUS_KEY, s->isPresent() ? libjami::Presence::ONLINE_KEY : libjami::Presence::OFFLINE_KEY}, + {libjami::Presence::LINESTATUS_KEY, std::string(s->getLineStatus())}}); } } else JAMI_ERR("Presence not initialized"); @@ -140,9 +140,9 @@ getSubscriptions(const std::string& accountID) ret.reserve(trackedBuddies.size()); for (const auto& tracked_id : trackedBuddies) { ret.push_back( - {{DRing::Presence::BUDDY_KEY, tracked_id.first}, - {DRing::Presence::STATUS_KEY, - tracked_id.second ? DRing::Presence::ONLINE_KEY : DRing::Presence::OFFLINE_KEY}}); + {{libjami::Presence::BUDDY_KEY, tracked_id.first}, + {libjami::Presence::STATUS_KEY, + tracked_id.second ? libjami::Presence::ONLINE_KEY : libjami::Presence::OFFLINE_KEY}}); } } else JAMI_ERR("Could not find account %s.", accountID.c_str()); @@ -170,4 +170,4 @@ setSubscriptions(const std::string& accountID, const std::vector& u JAMI_ERR("Could not find account %s.", accountID.c_str()); } -} // namespace DRing +} // namespace libjami diff --git a/src/client/ring_signal.cpp b/src/client/ring_signal.cpp index 274a3e73a..6906887eb 100644 --- a/src/client/ring_signal.cpp +++ b/src/client/ring_signal.cpp @@ -27,121 +27,121 @@ getSignalHandlers() { static SignalHandlerMap handlers = { /* Call */ - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), /* Configuration */ - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) - exported_callback(), + exported_callback(), #endif #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) || defined(RING_UWP) - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), #endif - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), /* Presence */ - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), /* Audio */ - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), /* DataTransfer */ - exported_callback(), + exported_callback(), #ifdef ENABLE_VIDEO /* MediaPlayer */ - exported_callback(), + exported_callback(), /* Video */ - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), #ifdef __ANDROID__ - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), #endif - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), #endif /* Conversation */ - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), - exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), #ifdef ENABLE_PLUGIN - exported_callback(), + exported_callback(), #endif }; @@ -150,7 +150,7 @@ getSignalHandlers() }; // namespace jami -namespace DRing { +namespace libjami { void registerSignalHandlers(const std::map>& handlers) @@ -175,4 +175,4 @@ unregisterSignalHandlers() } } -} // namespace DRing +} // namespace libjami diff --git a/src/client/ring_signal.h b/src/client/ring_signal.h index 94c9582e6..aa3505595 100644 --- a/src/client/ring_signal.h +++ b/src/client/ring_signal.h @@ -55,7 +55,7 @@ namespace jami { -using SignalHandlerMap = std::map>; +using SignalHandlerMap = std::map>; extern SignalHandlerMap& getSignalHandlers(); /* @@ -70,7 +70,7 @@ void emitSignal(Args... args) jami_tracepoint_if_enabled(emit_signal, demangle().c_str()); const auto& handlers = getSignalHandlers(); - if (auto wrap = DRing::CallbackWrapper(handlers.at(Ts::name))) { + if (auto wrap = libjami::CallbackWrapper(handlers.at(Ts::name))) { try { auto cb = *wrap; jami_tracepoint(emit_signal_begin_callback, @@ -87,11 +87,11 @@ void emitSignal(Args... args) #pragma GCC diagnostic pop template -std::pair>> +std::pair>> exported_callback() { return std::make_pair((const std::string&) Ts::name, - std::make_shared>()); + std::make_shared>()); } } // namespace jami diff --git a/src/client/videomanager.cpp b/src/client/videomanager.cpp index a0d43c0a0..b6b45d451 100644 --- a/src/client/videomanager.cpp +++ b/src/client/videomanager.cpp @@ -55,7 +55,7 @@ extern "C" { #include } -namespace DRing { +namespace libjami { MediaFrame::MediaFrame() : frame_ {av_frame_alloc()} @@ -554,18 +554,18 @@ getRenderer(const std::string& callId) #ifdef ENABLE_VIDEO if (auto sink = jami::Manager::instance().getSinkClient(callId)) return { - {DRing::Media::Details::CALL_ID, callId}, - {DRing::Media::Details::SHM_PATH, sink->openedName()}, - {DRing::Media::Details::WIDTH, std::to_string(sink->getWidth())}, - {DRing::Media::Details::HEIGHT, std::to_string(sink->getHeight())}, + {libjami::Media::Details::CALL_ID, callId}, + {libjami::Media::Details::SHM_PATH, sink->openedName()}, + {libjami::Media::Details::WIDTH, std::to_string(sink->getWidth())}, + {libjami::Media::Details::HEIGHT, std::to_string(sink->getHeight())}, }; else #endif return { - {DRing::Media::Details::CALL_ID, callId}, - {DRing::Media::Details::SHM_PATH, ""}, - {DRing::Media::Details::WIDTH, "0"}, - {DRing::Media::Details::HEIGHT, "0"}, + {libjami::Media::Details::CALL_ID, callId}, + {libjami::Media::Details::SHM_PATH, ""}, + {libjami::Media::Details::WIDTH, "0"}, + {libjami::Media::Details::HEIGHT, "0"}, }; } @@ -671,7 +671,7 @@ removeVideoDevice(const std::string& node) } #endif -} // namespace DRing +} // namespace libjami namespace jami { diff --git a/src/conference.cpp b/src/conference.cpp index 8828fee81..e1db05adf 100644 --- a/src/conference.cpp +++ b/src/conference.cpp @@ -376,9 +376,9 @@ Conference::setLocalHostDefaultMediaSource() void Conference::reportMediaNegotiationStatus() { - emitSignal( + emitSignal( getConfId(), - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS, currentMediaList()); } @@ -548,19 +548,19 @@ Conference::takeOverMediaSourceControl(const std::string& callId) JAMI_WARN("Take over [AUDIO] control from call %s - current local source state [%s]", callId.c_str(), muted ? "muted" : "un-muted"); - emitSignal(id_, muted); + emitSignal(id_, muted); } else { bool muted = isMediaSourceMuted(MediaType::MEDIA_VIDEO); JAMI_WARN("Take over [VIDEO] control from call %s - current local source state [%s]", callId.c_str(), muted ? "muted" : "un-muted"); - emitSignal(id_, muted); + emitSignal(id_, muted); } } } bool -Conference::requestMediaChange(const std::vector& mediaList) +Conference::requestMediaChange(const std::vector& mediaList) { if (getState() != State::ACTIVE_ATTACHED) { JAMI_ERR("[conf %s] Request media change can be performed only in attached mode", @@ -595,8 +595,8 @@ Conference::requestMediaChange(const std::vector& mediaList) // will set the new source as input. muteLocalHost(mediaAttr.muted_, mediaAttr.type_ == MediaType::MEDIA_AUDIO - ? DRing::Media::Details::MEDIA_TYPE_AUDIO - : DRing::Media::Details::MEDIA_TYPE_VIDEO); + ? libjami::Media::Details::MEDIA_TYPE_AUDIO + : libjami::Media::Details::MEDIA_TYPE_VIDEO); } } } @@ -612,7 +612,7 @@ Conference::requestMediaChange(const std::vector& mediaList) void Conference::handleMediaChangeRequest(const std::shared_ptr& call, - const std::vector& remoteMediaList) + const std::vector& remoteMediaList) { JAMI_DBG("Conf [%s] Answer to media change request", getConfId().c_str()); auto currentMediaList = hostSources_; @@ -632,15 +632,15 @@ Conference::handleMediaChangeRequest(const std::shared_ptr& call, auto remoteList = remoteMediaList; for (auto it = remoteList.begin(); it != remoteList.end();) { - if (it->at(DRing::Media::MediaAttributeKey::MUTED) == TRUE_STR - or it->at(DRing::Media::MediaAttributeKey::ENABLED) == FALSE_STR) { + if (it->at(libjami::Media::MediaAttributeKey::MUTED) == TRUE_STR + or it->at(libjami::Media::MediaAttributeKey::ENABLED) == FALSE_STR) { it = remoteList.erase(it); } else { ++it; } } // Create minimum media list (ignore muted and disabled medias) - std::vector newMediaList; + std::vector newMediaList; newMediaList.reserve(remoteMediaList.size()); for (auto const& media : currentMediaList) { if (media.enabled_ and not media.muted_) @@ -844,7 +844,7 @@ Conference::sendConferenceInfos() #endif // Inform client that layout has changed - jami::emitSignal(id_, + jami::emitSignal(id_, confInfo.toVectorMapStringString()); } @@ -1584,7 +1584,7 @@ Conference::hangupParticipant(const std::string& accountUri, const std::string& } if (auto call = getCallFromPeerID(string_remove_suffix(remoteHost, '@'))) { // Forward to the remote host. - DRing::hangupParticipant(acc->getAccountID(), call->getCallId(), accountUri, deviceId); + libjami::hangupParticipant(acc->getAccountID(), call->getCallId(), accountUri, deviceId); } } } @@ -1592,7 +1592,7 @@ Conference::hangupParticipant(const std::string& accountUri, const std::string& void Conference::muteLocalHost(bool is_muted, const std::string& mediaType) { - if (mediaType.compare(DRing::Media::Details::MEDIA_TYPE_AUDIO) == 0) { + if (mediaType.compare(libjami::Media::Details::MEDIA_TYPE_AUDIO) == 0) { if (is_muted == isMediaSourceMuted(MediaType::MEDIA_AUDIO)) { JAMI_DBG("Local audio source already in [%s] state", is_muted ? "muted" : "un-muted"); return; @@ -1608,9 +1608,9 @@ Conference::muteLocalHost(bool is_muted, const std::string& mediaType) } setLocalHostMuteState(MediaType::MEDIA_AUDIO, is_muted); updateMuted(); - emitSignal(id_, is_muted); + emitSignal(id_, is_muted); return; - } else if (mediaType.compare(DRing::Media::Details::MEDIA_TYPE_VIDEO) == 0) { + } else if (mediaType.compare(libjami::Media::Details::MEDIA_TYPE_VIDEO) == 0) { #ifdef ENABLE_VIDEO if (not isVideoEnabled()) { JAMI_ERR("Cant't mute, the video is disabled!"); @@ -1638,7 +1638,7 @@ Conference::muteLocalHost(bool is_muted, const std::string& mediaType) mixer->switchInputs(videoInputs); } } - emitSignal(id_, is_muted); + emitSignal(id_, is_muted); return; #endif } diff --git a/src/conference.h b/src/conference.h index d50f6bc12..defb1f540 100644 --- a/src/conference.h +++ b/src/conference.h @@ -271,7 +271,7 @@ public: * @param remoteMediaList new media list from the remote * @return true on success */ - bool requestMediaChange(const std::vector& mediaList); + bool requestMediaChange(const std::vector& mediaList); /** * Process incoming media change request. @@ -280,7 +280,7 @@ public: * @param remoteMediaList new media list from the remote */ void handleMediaChangeRequest(const std::shared_ptr& call, - const std::vector& remoteMediaList); + const std::vector& remoteMediaList); /** * Add a new participant to the conference @@ -393,7 +393,7 @@ public: * Retrieve current medias list * @return current medias */ - std::vector currentMediaList() const; + std::vector currentMediaList() const; // Update layout if recording changes void stopRecording() override; diff --git a/src/data_transfer.cpp b/src/data_transfer.cpp index 4a902c530..9256d7450 100644 --- a/src/data_transfer.cpp +++ b/src/data_transfer.cpp @@ -48,11 +48,11 @@ namespace jami { -DRing::DataTransferId +libjami::DataTransferId generateUID() { thread_local dht::crypto::random_device rd; - return std::uniform_int_distribution {1, JAMI_ID_MAX_VAL}(rd); + return std::uniform_int_distribution {1, JAMI_ID_MAX_VAL}(rd); } constexpr const uint32_t MAX_BUFFER_SIZE {65534}; /* Channeled max packet size */ @@ -61,7 +61,7 @@ constexpr const uint32_t MAX_BUFFER_SIZE {65534}; /* Channeled max packet size * class DataTransfer : public Stream { public: - DataTransfer(DRing::DataTransferId id, InternalCompletionCb cb = {}) + DataTransfer(libjami::DataTransferId id, InternalCompletionCb cb = {}) : Stream() , id {id} , internalCompletionCb_ {std::move(cb)} @@ -69,7 +69,7 @@ public: virtual ~DataTransfer() = default; - DRing::DataTransferId getId() const override { return id; } + libjami::DataTransferId getId() const override { return id; } virtual void accept(const std::string&, std::size_t) {}; @@ -97,7 +97,7 @@ public: info_.bytesProgress = progress; } - void info(DRing::DataTransferInfo& info) const + void info(libjami::DataTransferInfo& info) const { std::lock_guard lk {infoMutex_}; info = info_; @@ -106,14 +106,14 @@ public: bool isFinished() const { std::lock_guard lk {infoMutex_}; - return info_.lastEvent >= DRing::DataTransferEventCode::finished; + return info_.lastEvent >= libjami::DataTransferEventCode::finished; } - DRing::DataTransferInfo info() const { return info_; } + libjami::DataTransferInfo info() const { return info_; } - virtual void emit(DRing::DataTransferEventCode code) const; + virtual void emit(libjami::DataTransferEventCode code) const; - const DRing::DataTransferId id; + const libjami::DataTransferId id; virtual void cancel() {} @@ -121,7 +121,7 @@ public: protected: mutable std::mutex infoMutex_; - mutable DRing::DataTransferInfo info_; + mutable libjami::DataTransferInfo info_; mutable std::atomic_bool started_ {false}; std::atomic_bool wasStarted_ {false}; InternalCompletionCb internalCompletionCb_ {}; @@ -129,7 +129,7 @@ protected: }; void -DataTransfer::emit(DRing::DataTransferEventCode code) const +DataTransfer::emit(libjami::DataTransferEventCode code) const { std::string accountId, to; { @@ -145,7 +145,7 @@ DataTransfer::emit(DRing::DataTransferEventCode code) const if (internalCompletionCb_) return; // VCard transfer is just for the daemon runOnMainThread([id = id, code, accountId, to]() { - emitSignal(accountId, + emitSignal(accountId, "", "", std::to_string(id), @@ -171,14 +171,14 @@ DataTransfer::setOnStateChangedCb(const OnStateChangedCb& cb) class OptimisticMetaOutgoingInfo { public: - OptimisticMetaOutgoingInfo(const DataTransfer* parent, const DRing::DataTransferInfo& info); + OptimisticMetaOutgoingInfo(const DataTransfer* parent, const libjami::DataTransferInfo& info); /** * Update the DataTransferInfo of the parent if necessary (if the event is more *interesting* * for the user) * @param info the last modified linked info (for example if a subtransfer is accepted, it will * gives as a parameter its info) */ - void updateInfo(const DRing::DataTransferInfo& info) const; + void updateInfo(const libjami::DataTransferInfo& info) const; /** * Add a subtransfer as a linked transfer * @param linked @@ -187,51 +187,51 @@ public: /** * Return the optimistic representation of the transfer */ - const DRing::DataTransferInfo& info() const; + const libjami::DataTransferInfo& info() const; private: const DataTransfer* parent_; mutable std::mutex infoMutex_; - mutable DRing::DataTransferInfo info_; + mutable libjami::DataTransferInfo info_; mutable std::vector linkedTransfers_; }; OptimisticMetaOutgoingInfo::OptimisticMetaOutgoingInfo(const DataTransfer* parent, - const DRing::DataTransferInfo& info) + const libjami::DataTransferInfo& info) : parent_(parent) , info_(info) {} void -OptimisticMetaOutgoingInfo::updateInfo(const DRing::DataTransferInfo& info) const +OptimisticMetaOutgoingInfo::updateInfo(const libjami::DataTransferInfo& info) const { bool emitCodeChanged = false; bool checkOngoing = false; { std::lock_guard lk {infoMutex_}; - if (info_.lastEvent > DRing::DataTransferEventCode::timeout_expired) { - info_.lastEvent = DRing::DataTransferEventCode::invalid; + if (info_.lastEvent > libjami::DataTransferEventCode::timeout_expired) { + info_.lastEvent = libjami::DataTransferEventCode::invalid; } - if (info.lastEvent >= DRing::DataTransferEventCode::created - && info.lastEvent <= DRing::DataTransferEventCode::finished + if (info.lastEvent >= libjami::DataTransferEventCode::created + && info.lastEvent <= libjami::DataTransferEventCode::finished && info.lastEvent > info_.lastEvent) { // Show the more advanced info info_.lastEvent = info.lastEvent; emitCodeChanged = true; } - if (info.lastEvent >= DRing::DataTransferEventCode::closed_by_host - && info.lastEvent <= DRing::DataTransferEventCode::timeout_expired - && info_.lastEvent < DRing::DataTransferEventCode::finished) { + if (info.lastEvent >= libjami::DataTransferEventCode::closed_by_host + && info.lastEvent <= libjami::DataTransferEventCode::timeout_expired + && info_.lastEvent < libjami::DataTransferEventCode::finished) { // if not finished show error if all failed // if the transfer was ongoing and canceled, we should go to the best status bool isAllFailed = true; - checkOngoing = info_.lastEvent == DRing::DataTransferEventCode::ongoing; - DRing::DataTransferEventCode bestEvent {DRing::DataTransferEventCode::invalid}; + checkOngoing = info_.lastEvent == libjami::DataTransferEventCode::ongoing; + libjami::DataTransferEventCode bestEvent {libjami::DataTransferEventCode::invalid}; for (const auto* transfer : linkedTransfers_) { const auto& i = transfer->info(); - if (i.lastEvent >= DRing::DataTransferEventCode::created - && i.lastEvent <= DRing::DataTransferEventCode::finished) { + if (i.lastEvent >= libjami::DataTransferEventCode::created + && i.lastEvent <= libjami::DataTransferEventCode::finished) { isAllFailed = false; if (checkOngoing) bestEvent = bestEvent > i.lastEvent ? bestEvent : i.lastEvent; @@ -242,7 +242,7 @@ OptimisticMetaOutgoingInfo::updateInfo(const DRing::DataTransferInfo& info) cons if (isAllFailed) { info_.lastEvent = info.lastEvent; emitCodeChanged = true; - } else if (checkOngoing && bestEvent != DRing::DataTransferEventCode::invalid) { + } else if (checkOngoing && bestEvent != libjami::DataTransferEventCode::invalid) { info_.lastEvent = bestEvent; emitCodeChanged = true; } @@ -259,7 +259,7 @@ OptimisticMetaOutgoingInfo::updateInfo(const DRing::DataTransferInfo& info) cons info_.bytesProgress = bytesProgress; parent_->setBytesProgress(info_.bytesProgress); } - if (checkOngoing && info_.lastEvent != DRing::DataTransferEventCode::invalid) { + if (checkOngoing && info_.lastEvent != libjami::DataTransferEventCode::invalid) { parent_->setBytesProgress(0); } } @@ -276,7 +276,7 @@ OptimisticMetaOutgoingInfo::addLinkedTransfer(DataTransfer* linked) const linkedTransfers_.emplace_back(linked); } -const DRing::DataTransferInfo& +const libjami::DataTransferInfo& OptimisticMetaOutgoingInfo::info() const { return info_; @@ -288,16 +288,16 @@ OptimisticMetaOutgoingInfo::info() const class SubOutgoingFileTransfer final : public DataTransfer { public: - SubOutgoingFileTransfer(DRing::DataTransferId tid, + SubOutgoingFileTransfer(libjami::DataTransferId tid, const std::string& peerUri, const InternalCompletionCb& cb, std::shared_ptr metaInfo); ~SubOutgoingFileTransfer(); void close() noexcept override; - void closeAndEmit(DRing::DataTransferEventCode code) const noexcept; + void closeAndEmit(libjami::DataTransferEventCode code) const noexcept; bool write(std::string_view) override; - void emit(DRing::DataTransferEventCode code) const override; + void emit(libjami::DataTransferEventCode code) const override; const std::string& peer() { return peerUri_; } void cancel() override @@ -331,7 +331,7 @@ private: info_.totalSize, info_.displayName); headerSent_ = true; - emit(DRing::DataTransferEventCode::wait_peer_acceptance); + emit(libjami::DataTransferEventCode::wait_peer_acceptance); if (onRecvCb_) onRecvCb_(header); } @@ -356,11 +356,11 @@ private: JAMI_DBG() << "FTP#" << getId() << ": sent " << info_.bytesProgress << " bytes"; if (info_.bytesProgress != info_.totalSize) - emit(DRing::DataTransferEventCode::closed_by_peer); + emit(libjami::DataTransferEventCode::closed_by_peer); else { if (internalCompletionCb_) internalCompletionCb_(info_.path); - emit(DRing::DataTransferEventCode::finished); + emit(libjami::DataTransferEventCode::finished); } }); } @@ -375,7 +375,7 @@ private: std::function onRecvCb_ {}; }; -SubOutgoingFileTransfer::SubOutgoingFileTransfer(DRing::DataTransferId tid, +SubOutgoingFileTransfer::SubOutgoingFileTransfer(libjami::DataTransferId tid, const std::string& peerUri, const InternalCompletionCb& cb, std::shared_ptr metaInfo) @@ -399,16 +399,16 @@ SubOutgoingFileTransfer::~SubOutgoingFileTransfer() void SubOutgoingFileTransfer::close() noexcept { - closeAndEmit(DRing::DataTransferEventCode::closed_by_host); + closeAndEmit(libjami::DataTransferEventCode::closed_by_host); } void -SubOutgoingFileTransfer::closeAndEmit(DRing::DataTransferEventCode code) const noexcept +SubOutgoingFileTransfer::closeAndEmit(libjami::DataTransferEventCode code) const noexcept { started_ = false; // NOTE: replace DataTransfer::close(); which is non const input_.close(); - if (info_.lastEvent < DRing::DataTransferEventCode::finished) + if (info_.lastEvent < libjami::DataTransferEventCode::finished) emit(code); } @@ -421,13 +421,13 @@ SubOutgoingFileTransfer::write(std::string_view buffer) // detect GO or NGO msg if (buffer.size() == 3 and buffer[0] == 'G' and buffer[1] == 'O' and buffer[2] == '\n') { peerReady_ = true; - emit(DRing::DataTransferEventCode::ongoing); + emit(libjami::DataTransferEventCode::ongoing); if (onRecvCb_) sendFile(); } else { // consider any other response as a cancel msg JAMI_WARN() << "FTP#" << getId() << ": refused by peer"; - emit(DRing::DataTransferEventCode::closed_by_peer); + emit(libjami::DataTransferEventCode::closed_by_peer); return false; } } @@ -435,7 +435,7 @@ SubOutgoingFileTransfer::write(std::string_view buffer) } void -SubOutgoingFileTransfer::emit(DRing::DataTransferEventCode code) const +SubOutgoingFileTransfer::emit(libjami::DataTransferEventCode code) const { { std::lock_guard lk {infoMutex_}; @@ -444,13 +444,13 @@ SubOutgoingFileTransfer::emit(DRing::DataTransferEventCode code) const if (stateChangedCb_) stateChangedCb_(id, code); metaInfo_->updateInfo(info_); - if (code == DRing::DataTransferEventCode::wait_peer_acceptance) { + if (code == libjami::DataTransferEventCode::wait_peer_acceptance) { if (timeoutTask_) timeoutTask_->cancel(); timeoutTask_ = Manager::instance().scheduleTaskIn( [this]() { JAMI_WARN() << "FTP#" << getId() << ": timeout. Cancel"; - closeAndEmit(DRing::DataTransferEventCode::timeout_expired); + closeAndEmit(libjami::DataTransferEventCode::timeout_expired); }, std::chrono::minutes(10)); } else if (timeoutTask_) { @@ -465,8 +465,8 @@ SubOutgoingFileTransfer::emit(DRing::DataTransferEventCode code) const class OutgoingFileTransfer final : public DataTransfer { public: - OutgoingFileTransfer(DRing::DataTransferId tid, - const DRing::DataTransferInfo& info, + OutgoingFileTransfer(libjami::DataTransferId tid, + const libjami::DataTransferInfo& info, const InternalCompletionCb& cb = {}); ~OutgoingFileTransfer() {} @@ -513,8 +513,8 @@ private: mutable std::vector> subtransfer_; }; -OutgoingFileTransfer::OutgoingFileTransfer(DRing::DataTransferId tid, - const DRing::DataTransferInfo& info, +OutgoingFileTransfer::OutgoingFileTransfer(libjami::DataTransferId tid, + const libjami::DataTransferInfo& info, const InternalCompletionCb& cb) : DataTransfer(tid, cb) { @@ -523,7 +523,7 @@ OutgoingFileTransfer::OutgoingFileTransfer(DRing::DataTransferId tid, throw std::runtime_error("input file open failed"); info_ = info; - info_.flags &= ~((uint32_t) 1 << int(DRing::DataTransferFlags::direction)); // outgoing + info_.flags &= ~((uint32_t) 1 << int(libjami::DataTransferFlags::direction)); // outgoing // File size? input_.seekg(0, std::ios_base::end); @@ -545,8 +545,8 @@ OutgoingFileTransfer::close() noexcept class IncomingFileTransfer final : public DataTransfer { public: - IncomingFileTransfer(const DRing::DataTransferInfo&, - DRing::DataTransferId, + IncomingFileTransfer(const libjami::DataTransferInfo&, + libjami::DataTransferId, const InternalCompletionCb& cb = {}); bool start() override; @@ -571,15 +571,15 @@ public: private: IncomingFileTransfer() = delete; - DRing::DataTransferId internalId_; + libjami::DataTransferId internalId_; std::ofstream fout_; std::mutex cbMtx_ {}; std::function onFilenameCb_ {}; }; -IncomingFileTransfer::IncomingFileTransfer(const DRing::DataTransferInfo& info, - DRing::DataTransferId internalId, +IncomingFileTransfer::IncomingFileTransfer(const libjami::DataTransferInfo& info, + libjami::DataTransferId internalId, const InternalCompletionCb& cb) : DataTransfer(internalId, cb) , internalId_(internalId) @@ -588,7 +588,7 @@ IncomingFileTransfer::IncomingFileTransfer(const DRing::DataTransferInfo& info, << " byte(s): " << info.displayName; info_ = info; - info_.flags |= (uint32_t) 1 << int(DRing::DataTransferFlags::direction); // incoming + info_.flags |= (uint32_t) 1 << int(libjami::DataTransferFlags::direction); // incoming } void @@ -605,7 +605,7 @@ IncomingFileTransfer::requestFilename(const std::function lk {infoMutex_}; - if (info_.lastEvent >= DRing::DataTransferEventCode::finished) + if (info_.lastEvent >= libjami::DataTransferEventCode::finished) return; } DataTransfer::close(); @@ -661,9 +661,9 @@ IncomingFileTransfer::close() noexcept if (info_.bytesProgress >= info_.totalSize) { if (internalCompletionCb_) internalCompletionCb_(info_.path); - emit(DRing::DataTransferEventCode::finished); + emit(libjami::DataTransferEventCode::finished); } else - emit(DRing::DataTransferEventCode::closed_by_host); + emit(libjami::DataTransferEventCode::closed_by_host); } void @@ -702,7 +702,7 @@ IncomingFileTransfer::write(std::string_view buffer) FileInfo::FileInfo(const std::shared_ptr& channel, const std::string& fileId, const std::string& interactionId, - const DRing::DataTransferInfo& info) + const libjami::DataTransferInfo& info) : fileId_(fileId) , interactionId_(interactionId) , info_(info) @@ -710,14 +710,14 @@ FileInfo::FileInfo(const std::shared_ptr& channel, {} void -FileInfo::emit(DRing::DataTransferEventCode code) +FileInfo::emit(libjami::DataTransferEventCode code) { - if (finishedCb_ && code >= DRing::DataTransferEventCode::finished) + if (finishedCb_ && code >= libjami::DataTransferEventCode::finished) finishedCb_(uint32_t(code)); if (interactionId_ != "") { // Else it's an internal transfer runOnMainThread([info = info_, iid = interactionId_, fid = fileId_, code]() { - emitSignal(info.accountId, + emitSignal(info.accountId, info.conversationId, iid, fid, @@ -729,7 +729,7 @@ FileInfo::emit(DRing::DataTransferEventCode code) OutgoingFile::OutgoingFile(const std::shared_ptr& channel, const std::string& fileId, const std::string& interactionId, - const DRing::DataTransferInfo& info, + const libjami::DataTransferInfo& info, size_t start, size_t end) : FileInfo(channel, fileId, interactionId, info) @@ -787,8 +787,8 @@ OutgoingFile::process() // will retry the transfer if they need, so we don't need to show errors. if (!interactionId_.empty() && !correct) return; - auto code = correct ? DRing::DataTransferEventCode::finished - : DRing::DataTransferEventCode::closed_by_peer; + auto code = correct ? libjami::DataTransferEventCode::finished + : libjami::DataTransferEventCode::closed_by_peer; emit(code); } } @@ -803,11 +803,11 @@ OutgoingFile::cancel() if (fileutils::isSymLink(path)) fileutils::remove(path); isUserCancelled_ = true; - emit(DRing::DataTransferEventCode::closed_by_host); + emit(libjami::DataTransferEventCode::closed_by_host); } IncomingFile::IncomingFile(const std::shared_ptr& channel, - const DRing::DataTransferInfo& info, + const libjami::DataTransferInfo& info, const std::string& fileId, const std::string& interactionId, const std::string& sha3Sum) @@ -818,7 +818,7 @@ IncomingFile::IncomingFile(const std::shared_ptr& channel, if (!stream_) return; - emit(DRing::DataTransferEventCode::ongoing); + emit(libjami::DataTransferEventCode::ongoing); } IncomingFile::~IncomingFile() @@ -835,7 +835,7 @@ void IncomingFile::cancel() { isUserCancelled_ = true; - emit(DRing::DataTransferEventCode::closed_by_peer); + emit(libjami::DataTransferEventCode::closed_by_peer); if (channel_) channel_->shutdown(); } @@ -871,8 +871,8 @@ IncomingFile::process() } if (shared->isUserCancelled_) return; - auto code = correct ? DRing::DataTransferEventCode::finished - : DRing::DataTransferEventCode::closed_by_host; + auto code = correct ? libjami::DataTransferEventCode::finished + : libjami::DataTransferEventCode::closed_by_host; shared->emit(code); }); } @@ -935,8 +935,8 @@ public: std::string conversationDataPath_ {}; // Pre swarm - std::map> oMap_ {}; - std::map> iMap_ {}; + std::map> oMap_ {}; + std::map> iMap_ {}; std::mutex mapMutex_ {}; std::map waitingIds_ {}; @@ -951,7 +951,7 @@ TransferManager::TransferManager(const std::string& accountId, const std::string TransferManager::~TransferManager() {} -DRing::DataTransferId +libjami::DataTransferId TransferManager::sendFile(const std::string& path, const std::string& peer, const InternalCompletionCb& icb) @@ -968,7 +968,7 @@ TransferManager::sendFile(const std::string& path, std::size_t found = path.find_last_of(DIR_SEPARATOR_CH); auto filename = path.substr(found + 1); - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = pimpl_->accountId_; info.author = account->getUsername(); info.peer = peer; @@ -991,7 +991,7 @@ TransferManager::sendFile(const std::string& path, } pimpl_->oMap_.emplace(tid, transfer); } - transfer->emit(DRing::DataTransferEventCode::created); + transfer->emit(libjami::DataTransferEventCode::created); try { account->requestConnection( @@ -1005,7 +1005,7 @@ TransferManager::sendFile(const std::string& path, [transfer](const std::string& peer) { auto allFinished = transfer->cancelWithPeer(peer); if (allFinished and not transfer->hasBeenStarted()) { - transfer->emit(DRing::DataTransferEventCode::unjoinable_peer); + transfer->emit(libjami::DataTransferEventCode::unjoinable_peer); transfer->cancel(); transfer->close(); } @@ -1019,7 +1019,7 @@ TransferManager::sendFile(const std::string& path, } bool -TransferManager::acceptFile(const DRing::DataTransferId& id, const std::string& path) +TransferManager::acceptFile(const libjami::DataTransferId& id, const std::string& path) { std::lock_guard lk {pimpl_->mapMutex_}; auto it = pimpl_->iMap_.find(id); @@ -1042,7 +1042,7 @@ TransferManager::transferFile(const std::shared_ptr& channel, std::lock_guard lk {pimpl_->mapMutex_}; if (pimpl_->outgoings_.find(channel) != pimpl_->outgoings_.end()) return; - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = pimpl_->accountId_; info.conversationId = pimpl_->to_; info.path = path; @@ -1108,7 +1108,7 @@ TransferManager::cancel(const std::string& fileId) } bool -TransferManager::info(const DRing::DataTransferId& id, DRing::DataTransferInfo& info) const noexcept +TransferManager::info(const libjami::DataTransferId& id, libjami::DataTransferInfo& info) const noexcept { std::unique_lock lk {pimpl_->mapMutex_}; if (!pimpl_->to_.empty()) @@ -1166,8 +1166,8 @@ TransferManager::info(const std::string& fileId, } void -TransferManager::onIncomingFileRequest(const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, +TransferManager::onIncomingFileRequest(const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const std::function& cb, const InternalCompletionCb& icb) { @@ -1176,7 +1176,7 @@ TransferManager::onIncomingFileRequest(const DRing::DataTransferInfo& info, std::lock_guard lk {pimpl_->mapMutex_}; pimpl_->iMap_.emplace(id, transfer); } - transfer->emit(DRing::DataTransferEventCode::created); + transfer->emit(libjami::DataTransferEventCode::created); transfer->requestFilename([transfer, id, cb = std::move(cb)](const std::string& filename) { if (!filename.empty() && transfer->start()) cb({id, std::static_pointer_cast(transfer)}); @@ -1201,12 +1201,12 @@ TransferManager::waitForTransfer(const std::string& fileId, if (!pimpl_->to_.empty()) pimpl_->saveWaiting(); lk.unlock(); - emitSignal( + emitSignal( pimpl_->accountId_, pimpl_->to_, interactionId, fileId, - uint32_t(DRing::DataTransferEventCode::wait_peer_acceptance)); + uint32_t(libjami::DataTransferEventCode::wait_peer_acceptance)); } void @@ -1226,7 +1226,7 @@ TransferManager::onIncomingFileTransfer(const std::string& fileId, return; } - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = pimpl_->accountId_; info.conversationId = pimpl_->to_; info.path = itW->second.path; @@ -1261,7 +1261,7 @@ TransferManager::onIncomingFileTransfer(const std::string& fileId, auto itO = pimpl->incomings_.find(fileId); if (itO != pimpl->incomings_.end()) pimpl->incomings_.erase(itO); - if (code == uint32_t(DRing::DataTransferEventCode::finished)) { + if (code == uint32_t(libjami::DataTransferEventCode::finished)) { auto itW = pimpl->waitingIds_.find(fileId); if (itW != pimpl->waitingIds_.end()) { pimpl->waitingIds_.erase(itW); @@ -1309,7 +1309,7 @@ TransferManager::onIncomingProfile(const std::shared_ptr& channel } auto tid = generateUID(); - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = pimpl_->accountId_; info.conversationId = pimpl_->to_; info.path = fileutils::get_cache_dir() + DIR_SEPARATOR_STR + pimpl_->accountId_ @@ -1339,8 +1339,8 @@ TransferManager::onIncomingProfile(const std::shared_ptr& channel auto itO = pimpl->vcards_.find({deviceId, uri}); if (itO != pimpl->vcards_.end()) pimpl->vcards_.erase(itO); - if (code == uint32_t(DRing::DataTransferEventCode::finished)) { - emitSignal(accountId, + if (code == uint32_t(libjami::DataTransferEventCode::finished)) { + emitSignal(accountId, uri, path); } diff --git a/src/data_transfer.h b/src/data_transfer.h index 4965a7c62..bea988378 100644 --- a/src/data_transfer.h +++ b/src/data_transfer.h @@ -31,13 +31,13 @@ namespace jami { -DRing::DataTransferId generateUID(); +libjami::DataTransferId generateUID(); class Stream; struct IncomingFileInfo { - DRing::DataTransferId id; + libjami::DataTransferId id; std::shared_ptr stream; }; @@ -52,7 +52,7 @@ struct WaitingRequest }; typedef std::function InternalCompletionCb; -typedef std::function +typedef std::function OnStateChangedCb; class FileInfo @@ -61,20 +61,20 @@ public: FileInfo(const std::shared_ptr& channel, const std::string& fileId, const std::string& interactionId, - const DRing::DataTransferInfo& info); + const libjami::DataTransferInfo& info); virtual ~FileInfo() {} virtual void process() = 0; std::shared_ptr channel() const { return channel_; } - DRing::DataTransferInfo info() const { return info_; } + libjami::DataTransferInfo info() const { return info_; } virtual void cancel() = 0; void onFinished(std::function&& cb) { finishedCb_ = std::move(cb); } - void emit(DRing::DataTransferEventCode code); + void emit(libjami::DataTransferEventCode code); protected: std::atomic_bool isUserCancelled_ {false}; std::string fileId_ {}; std::string interactionId_ {}; - DRing::DataTransferInfo info_ {}; + libjami::DataTransferInfo info_ {}; std::shared_ptr channel_ {}; std::function finishedCb_ {}; }; @@ -83,7 +83,7 @@ class IncomingFile : public FileInfo, public std::enable_shared_from_this& channel, - const DRing::DataTransferInfo& info, + const libjami::DataTransferInfo& info, const std::string& fileId, const std::string& interactionId, const std::string& sha3Sum = ""); @@ -106,7 +106,7 @@ public: OutgoingFile(const std::shared_ptr& channel, const std::string& fileId, const std::string& interactionId, - const DRing::DataTransferInfo& info, + const libjami::DataTransferInfo& info, size_t start = 0, size_t end = 0); ~OutgoingFile(); @@ -131,7 +131,7 @@ public: * @param peer DeviceId for vcard or dest * @param icb used for internal files (like vcard) */ - /*[[deprecated("Non swarm method")]]*/ DRing::DataTransferId sendFile( + /*[[deprecated("Non swarm method")]]*/ libjami::DataTransferId sendFile( const std::string& path, const std::string& peer, const InternalCompletionCb& icb = {}); /** @@ -139,7 +139,7 @@ public: * @param id of the transfer * @param path of the file */ - /*[[deprecated("Non swarm method")]]*/ bool acceptFile(const DRing::DataTransferId& id, + /*[[deprecated("Non swarm method")]]*/ bool acceptFile(const libjami::DataTransferId& id, const std::string& path); /** @@ -150,8 +150,8 @@ public: * @param icb used for vcard */ /*[[deprecated("Non swarm method")]]*/ void onIncomingFileRequest( - const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, + const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const std::function& cb, const InternalCompletionCb& icb = {}); @@ -161,8 +161,8 @@ public: * @param info to fill * @return if found */ - /*[[deprecated("Non swarm method")]]*/ bool info(const DRing::DataTransferId& id, - DRing::DataTransferInfo& info) const noexcept; + /*[[deprecated("Non swarm method")]]*/ bool info(const libjami::DataTransferId& id, + libjami::DataTransferInfo& info) const noexcept; /** * Send a file to a channel diff --git a/src/fileutils.cpp b/src/fileutils.cpp index aa7ff713b..8a48132d6 100644 --- a/src/fileutils.cpp +++ b/src/fileutils.cpp @@ -637,7 +637,7 @@ get_cache_dir(const char* pkg) std::string cache_path; std::vector paths; paths.reserve(1); - emitSignal("", &paths); + emitSignal("", &paths); if (not paths.empty()) { cache_path = paths[0] + DIR_SEPARATOR_STR + std::string(".cache"); if (fileutils::recursive_mkdir(cache_path.data(), 0700) != true) { @@ -650,7 +650,7 @@ get_cache_dir(const char* pkg) #elif defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) std::vector paths; paths.reserve(1); - emitSignal("cache", &paths); + emitSignal("cache", &paths); if (not paths.empty()) return paths[0]; return {}; @@ -683,14 +683,14 @@ get_home_dir() #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) std::vector paths; paths.reserve(1); - emitSignal("files", &paths); + emitSignal("files", &paths); if (not paths.empty()) return paths[0]; return {}; #elif defined RING_UWP std::vector paths; paths.reserve(1); - emitSignal("", &paths); + emitSignal("", &paths); if (not paths.empty()) return paths[0]; return {}; @@ -726,7 +726,7 @@ get_data_dir(const char* pkg) #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) std::vector paths; paths.reserve(1); - emitSignal("files", &paths); + emitSignal("files", &paths); if (not paths.empty()) return paths[0]; return {}; @@ -748,7 +748,7 @@ get_data_dir(const char* pkg) #elif defined(RING_UWP) std::vector paths; paths.reserve(1); - emitSignal("", &paths); + emitSignal("", &paths); if (not paths.empty()) { auto files_path = paths[0] + DIR_SEPARATOR_STR + std::string(".data"); if (fileutils::recursive_mkdir(files_path.data(), 0700) != true) { @@ -782,12 +782,12 @@ get_config_dir(const char* pkg) std::string configdir; #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) std::vector paths; - emitSignal("config", &paths); + emitSignal("config", &paths); if (not paths.empty()) configdir = std::move(paths[0]); #elif defined(RING_UWP) std::vector paths; - emitSignal("", &paths); + emitSignal("", &paths); if (not paths.empty()) configdir = paths[0] + DIR_SEPARATOR_STR + std::string(".config"); #elif defined(__APPLE__) diff --git a/src/fileutils.h b/src/fileutils.h index baad2dda8..0bc73ae0a 100644 --- a/src/fileutils.h +++ b/src/fileutils.h @@ -60,7 +60,7 @@ std::string get_cache_dir(); * @param parents default mode for all created directories except the last */ bool check_dir(const char* path, mode_t dir = 0755, mode_t parents = 0755); -DRING_PUBLIC void set_program_dir(char* program_path); // public because bin/main.cpp uses it +LIBJAMI_PUBLIC void set_program_dir(char* program_path); // public because bin/main.cpp uses it std::string expand_path(const std::string& path); bool isDirectoryWritable(const std::string& directory); diff --git a/src/ftp_server.cpp b/src/ftp_server.cpp index 1a8edc387..712c51377 100644 --- a/src/ftp_server.cpp +++ b/src/ftp_server.cpp @@ -39,8 +39,8 @@ namespace jami { //============================================================================== -FtpServer::FtpServer(const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, +FtpServer::FtpServer(const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const InternalCompletionCb& cb) : Stream() , info_ {info} @@ -48,7 +48,7 @@ FtpServer::FtpServer(const DRing::DataTransferInfo& info, , cb_(cb) {} -DRing::DataTransferId +libjami::DataTransferId FtpServer::getId() const { // Because FtpServer is just the protocol on the top of a stream so the id diff --git a/src/ftp_server.h b/src/ftp_server.h index e7d072777..fc5ab6198 100644 --- a/src/ftp_server.h +++ b/src/ftp_server.h @@ -35,12 +35,12 @@ using RecvCb = std::function; class FtpServer final : public Stream, public std::enable_shared_from_this { public: - FtpServer(const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, + FtpServer(const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const InternalCompletionCb& cb = {}); bool write(std::string_view data) override; - DRing::DataTransferId getId() const override; + libjami::DataTransferId getId() const override; void close() noexcept override; void setOnRecv(RecvCb&& cb) override { onRecvCb_ = cb; } @@ -68,11 +68,11 @@ private: READ_DATA, }; - DRing::DataTransferInfo info_; + libjami::DataTransferInfo info_; InternalCompletionCb cb_ {}; std::atomic_bool isVCard_ {false}; std::atomic_bool isTreatingRequest_ {false}; - DRing::DataTransferId transferId_ {0}; + libjami::DataTransferId transferId_ {0}; IncomingFileInfo out_ {0, nullptr}; std::size_t fileSize_ {0}; std::size_t rx_ {0}; diff --git a/src/im/message_engine.cpp b/src/im/message_engine.cpp index d9060d6ac..a52d49ce4 100644 --- a/src/im/message_engine.cpp +++ b/src/im/message_engine.cpp @@ -113,12 +113,12 @@ MessageEngine::retrySend(const std::string& peer, bool retryOnTimeout) for (const auto& p : pending) { JAMI_DBG() << "[message " << p.token << "] Retry sending"; if (p.payloads.find("application/im-gitmessage-id") == p.payloads.end()) - emitSignal( + emitSignal( account_.getAccountID(), "", p.to, std::to_string(p.token), - (int) DRing::Account::MessageStates::SENDING); + (int) libjami::Account::MessageStates::SENDING); account_.sendMessage(p.to, p.payloads, p.token, retryOnTimeout); } } @@ -146,12 +146,12 @@ MessageEngine::cancel(MessageToken t) == m->second.payloads.end(); m->second.status = MessageStatus::CANCELLED; if (emit) - emitSignal( + emitSignal( account_.getAccountID(), "", m->second.to, std::to_string(t), - static_cast(DRing::Account::MessageStates::CANCELLED)); + static_cast(libjami::Account::MessageStates::CANCELLED)); save_(); return true; } @@ -178,23 +178,23 @@ MessageEngine::onMessageSent(const std::string& peer, MessageToken token, bool o f->second.status = MessageStatus::SENT; JAMI_DBG() << "[message " << token << "] Status changed to SENT"; if (emit) - emitSignal( + emitSignal( account_.getAccountID(), "", f->second.to, std::to_string(token), - static_cast(DRing::Account::MessageStates::SENT)); + static_cast(libjami::Account::MessageStates::SENT)); save_(); } else if (f->second.retried >= MAX_RETRIES) { f->second.status = MessageStatus::FAILURE; JAMI_DBG() << "[message " << token << "] Status changed to FAILURE"; if (emit) - emitSignal( + emitSignal( account_.getAccountID(), "", f->second.to, std::to_string(token), - static_cast(DRing::Account::MessageStates::FAILURE)); + static_cast(libjami::Account::MessageStates::FAILURE)); save_(); } else { f->second.status = MessageStatus::IDLE; @@ -214,12 +214,12 @@ MessageEngine::onMessageDisplayed(const std::string& peer, MessageToken token, b if (not displayed) return; JAMI_DBG() << "[message " << token << "] Displayed by peer"; - emitSignal( + emitSignal( account_.getAccountID(), "", /* No related conversation */ peer, std::to_string(token), - static_cast(DRing::Account::MessageStates::DISPLAYED)); + static_cast(libjami::Account::MessageStates::DISPLAYED)); } void diff --git a/src/ip_utils.cpp b/src/ip_utils.cpp index 6dee30e29..33d620732 100644 --- a/src/ip_utils.cpp +++ b/src/ip_utils.cpp @@ -199,7 +199,7 @@ ip_utils::getDeviceName() { #if defined(__ANDROID__) || defined(RING_UWP) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) std::vector deviceNames; - emitSignal(&deviceNames); + emitSignal(&deviceNames); if (not deviceNames.empty()) { return deviceNames[0]; } diff --git a/src/jami/CMakeLists.txt b/src/jami/CMakeLists.txt index 69668506e..efef46197 100644 --- a/src/jami/CMakeLists.txt +++ b/src/jami/CMakeLists.txt @@ -1,7 +1,7 @@ ################################################################################ -# Source groups - dring +# Source groups - jami ################################################################################ -list (APPEND Source_Files__dring +list (APPEND Source_Files__jami "${CMAKE_CURRENT_SOURCE_DIR}/account_const.h" "${CMAKE_CURRENT_SOURCE_DIR}/call_const.h" "${CMAKE_CURRENT_SOURCE_DIR}/callmanager_interface.h" @@ -17,4 +17,4 @@ list (APPEND Source_Files__dring "${CMAKE_CURRENT_SOURCE_DIR}/videomanager_interface.h" ) -set (Source_Files__dring ${Source_Files__dring} PARENT_SCOPE) \ No newline at end of file +set (Source_Files__jami ${Source_Files__jami} PARENT_SCOPE) \ No newline at end of file diff --git a/src/jami/account_const.h b/src/jami/account_const.h index 08eef98dd..a636a199b 100644 --- a/src/jami/account_const.h +++ b/src/jami/account_const.h @@ -18,8 +18,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_ACCOUNT_H -#define DRING_ACCOUNT_H +#ifndef LIBJAMI_ACCOUNT_H +#define LIBJAMI_ACCOUNT_H #include "def.h" @@ -28,7 +28,7 @@ #undef ERROR #endif -namespace DRing { +namespace libjami { namespace Account { @@ -69,7 +69,7 @@ enum class MessageStates : int { DISPLAYED, FAILURE, CANCELLED -}; // DRing::Account::MessageStates +}; // libjami::Account::MessageStates namespace VolatileProperties { @@ -280,6 +280,6 @@ constexpr static const char CONVERSATIONID[] = "conversationId"; } // namespace Account -} // namespace DRing +} // namespace libjami #endif diff --git a/src/jami/call_const.h b/src/jami/call_const.h index 8c721d1f5..0088c6b38 100644 --- a/src/jami/call_const.h +++ b/src/jami/call_const.h @@ -17,12 +17,12 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_CALL_H -#define DRING_CALL_H +#ifndef LIBJAMI_CALL_H +#define LIBJAMI_CALL_H #include "def.h" -namespace DRing { +namespace libjami { namespace Call { @@ -65,6 +65,6 @@ constexpr static char VIDEO_CODEC[] = "VIDEO_CODEC"; } // namespace Call -} // namespace DRing +} // namespace libjami #endif diff --git a/src/jami/callmanager_interface.h b/src/jami/callmanager_interface.h index db17c803f..85e9d1cfd 100644 --- a/src/jami/callmanager_interface.h +++ b/src/jami/callmanager_interface.h @@ -19,8 +19,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_CALLMANAGERI_H -#define DRING_CALLMANAGERI_H +#ifndef LIBJAMI_CALLMANAGERI_H +#define LIBJAMI_CALLMANAGERI_H #include "def.h" @@ -33,44 +33,44 @@ #include "jami.h" -namespace DRing { +namespace libjami { -[[deprecated("Replaced by registerSignalHandlers")]] DRING_PUBLIC void registerCallHandlers( +[[deprecated("Replaced by registerSignalHandlers")]] LIBJAMI_PUBLIC void registerCallHandlers( const std::map>&); /* Call related methods */ -DRING_PUBLIC std::string placeCall(const std::string& accountId, const std::string& to); +LIBJAMI_PUBLIC std::string placeCall(const std::string& accountId, const std::string& to); -DRING_PUBLIC std::string placeCallWithMedia( +LIBJAMI_PUBLIC std::string placeCallWithMedia( const std::string& accountId, const std::string& to, const std::vector>& mediaList); -DRING_PUBLIC bool refuse(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool accept(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool hangUp(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool hold(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool unhold(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool muteLocalMedia(const std::string& accountId, +LIBJAMI_PUBLIC bool refuse(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool accept(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool hangUp(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool hold(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool unhold(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool muteLocalMedia(const std::string& accountId, const std::string& callId, const std::string& mediaType, bool mute); -DRING_PUBLIC bool transfer(const std::string& accountId, +LIBJAMI_PUBLIC bool transfer(const std::string& accountId, const std::string& callId, const std::string& to); -DRING_PUBLIC bool attendedTransfer(const std::string& accountId, +LIBJAMI_PUBLIC bool attendedTransfer(const std::string& accountId, const std::string& callId, const std::string& targetID); -DRING_PUBLIC std::map getCallDetails(const std::string& accountId, +LIBJAMI_PUBLIC std::map getCallDetails(const std::string& accountId, const std::string& callId); -DRING_PUBLIC std::vector getCallList(const std::string& accountId); +LIBJAMI_PUBLIC std::vector getCallList(const std::string& accountId); /* APIs that supports an arbitrary number of media */ -DRING_PUBLIC bool acceptWithMedia(const std::string& accountId, +LIBJAMI_PUBLIC bool acceptWithMedia(const std::string& accountId, const std::string& callId, - const std::vector& mediaList); -DRING_PUBLIC bool requestMediaChange(const std::string& accountId, + const std::vector& mediaList); +LIBJAMI_PUBLIC bool requestMediaChange(const std::string& accountId, const std::string& callId, - const std::vector& mediaList); + const std::vector& mediaList); /** * Answer a media change request @@ -82,147 +82,147 @@ DRING_PUBLIC bool requestMediaChange(const std::string& accountId, * The client can ignore the media update request by not calling this * method, or calling it with an empty media list. */ -DRING_PUBLIC bool answerMediaChangeRequest(const std::string& accountId, +LIBJAMI_PUBLIC bool answerMediaChangeRequest(const std::string& accountId, const std::string& callId, - const std::vector& mediaList); + const std::vector& mediaList); /* Conference related methods */ -DRING_PUBLIC bool joinParticipant(const std::string& accountId, +LIBJAMI_PUBLIC bool joinParticipant(const std::string& accountId, const std::string& sel_callId, const std::string& account2Id, const std::string& drag_callId); -DRING_PUBLIC void createConfFromParticipantList(const std::string& accountId, +LIBJAMI_PUBLIC void createConfFromParticipantList(const std::string& accountId, const std::vector& participants); -DRING_PUBLIC void setConferenceLayout(const std::string& accountId, +LIBJAMI_PUBLIC void setConferenceLayout(const std::string& accountId, const std::string& confId, uint32_t layout); -DRING_PUBLIC bool isConferenceParticipant(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool addParticipant(const std::string& accountId, +LIBJAMI_PUBLIC bool isConferenceParticipant(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool addParticipant(const std::string& accountId, const std::string& callId, const std::string& account2Id, const std::string& confId); -DRING_PUBLIC bool addMainParticipant(const std::string& accountId, const std::string& confId); -DRING_PUBLIC bool detachLocalParticipant(); -DRING_PUBLIC bool detachParticipant(const std::string& accountId, const std::string& callId); -DRING_PUBLIC bool joinConference(const std::string& accountId, +LIBJAMI_PUBLIC bool addMainParticipant(const std::string& accountId, const std::string& confId); +LIBJAMI_PUBLIC bool detachLocalParticipant(); +LIBJAMI_PUBLIC bool detachParticipant(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool joinConference(const std::string& accountId, const std::string& sel_confId, const std::string& account2Id, const std::string& drag_confId); -DRING_PUBLIC bool hangUpConference(const std::string& accountId, const std::string& confId); -DRING_PUBLIC bool holdConference(const std::string& accountId, const std::string& confId); -DRING_PUBLIC bool unholdConference(const std::string& accountId, const std::string& confId); -DRING_PUBLIC std::vector getConferenceList(const std::string& accountId); -DRING_PUBLIC std::vector getParticipantList(const std::string& accountId, +LIBJAMI_PUBLIC bool hangUpConference(const std::string& accountId, const std::string& confId); +LIBJAMI_PUBLIC bool holdConference(const std::string& accountId, const std::string& confId); +LIBJAMI_PUBLIC bool unholdConference(const std::string& accountId, const std::string& confId); +LIBJAMI_PUBLIC std::vector getConferenceList(const std::string& accountId); +LIBJAMI_PUBLIC std::vector getParticipantList(const std::string& accountId, const std::string& confId); -DRING_PUBLIC std::string getConferenceId(const std::string& accountId, const std::string& callId); -DRING_PUBLIC std::map getConferenceDetails(const std::string& accountId, +LIBJAMI_PUBLIC std::string getConferenceId(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC std::map getConferenceDetails(const std::string& accountId, const std::string& callId); -DRING_PUBLIC std::vector currentMediaList(const std::string& accountId, +LIBJAMI_PUBLIC std::vector currentMediaList(const std::string& accountId, const std::string& callId); -DRING_PUBLIC std::vector> getConferenceInfos( +LIBJAMI_PUBLIC std::vector> getConferenceInfos( const std::string& accountId, const std::string& confId); -DRING_PUBLIC void setModerator(const std::string& accountId, +LIBJAMI_PUBLIC void setModerator(const std::string& accountId, const std::string& confId, const std::string& accountUri, const bool& state); /// DEPRECATED USE muteStream -DRING_PUBLIC void muteParticipant(const std::string& accountId, +LIBJAMI_PUBLIC void muteParticipant(const std::string& accountId, const std::string& confId, const std::string& accountUri, const bool& state); // Note: muting Audio not supported yet -DRING_PUBLIC void muteStream(const std::string& accountId, +LIBJAMI_PUBLIC void muteStream(const std::string& accountId, const std::string& confId, const std::string& accountUri, const std::string& deviceId, const std::string& streamId, const bool& state); /// DEPRECATED, USE setActiveStream -DRING_PUBLIC void setActiveParticipant(const std::string& accountId, +LIBJAMI_PUBLIC void setActiveParticipant(const std::string& accountId, const std::string& confId, const std::string& callId); -DRING_PUBLIC void setActiveStream(const std::string& accountId, +LIBJAMI_PUBLIC void setActiveStream(const std::string& accountId, const std::string& confId, const std::string& accountUri, const std::string& deviceId, const std::string& streamId, const bool& state); -DRING_PUBLIC void hangupParticipant(const std::string& accountId, +LIBJAMI_PUBLIC void hangupParticipant(const std::string& accountId, const std::string& confId, const std::string& accountUri, const std::string& deviceId); /// DEPRECATED, use raiseHand -DRING_PUBLIC void raiseParticipantHand(const std::string& accountId, +LIBJAMI_PUBLIC void raiseParticipantHand(const std::string& accountId, const std::string& confId, const std::string& peerId, const bool& state); -DRING_PUBLIC void raiseHand(const std::string& accountId, +LIBJAMI_PUBLIC void raiseHand(const std::string& accountId, const std::string& confId, const std::string& accountUri, const std::string& deviceId, const bool& state); /* Statistic related methods */ -DRING_PUBLIC void startSmartInfo(uint32_t refreshTimeMs); -DRING_PUBLIC void stopSmartInfo(); +LIBJAMI_PUBLIC void startSmartInfo(uint32_t refreshTimeMs); +LIBJAMI_PUBLIC void stopSmartInfo(); /* File Playback methods */ -DRING_PUBLIC bool startRecordedFilePlayback(const std::string& filepath); -DRING_PUBLIC void stopRecordedFilePlayback(); +LIBJAMI_PUBLIC bool startRecordedFilePlayback(const std::string& filepath); +LIBJAMI_PUBLIC void stopRecordedFilePlayback(); /* General audio methods */ -DRING_PUBLIC bool toggleRecording(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC bool toggleRecording(const std::string& accountId, const std::string& callId); /* DEPRECATED */ -DRING_PUBLIC void setRecording(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC void setRecording(const std::string& accountId, const std::string& callId); -DRING_PUBLIC void recordPlaybackSeek(double value); -DRING_PUBLIC bool getIsRecording(const std::string& accountId, const std::string& callId); -DRING_PUBLIC void playDTMF(const std::string& key); -DRING_PUBLIC void startTone(int32_t start, int32_t type); +LIBJAMI_PUBLIC void recordPlaybackSeek(double value); +LIBJAMI_PUBLIC bool getIsRecording(const std::string& accountId, const std::string& callId); +LIBJAMI_PUBLIC void playDTMF(const std::string& key); +LIBJAMI_PUBLIC void startTone(int32_t start, int32_t type); -DRING_PUBLIC bool switchInput(const std::string& accountId, +LIBJAMI_PUBLIC bool switchInput(const std::string& accountId, const std::string& callId, const std::string& resource); -DRING_PUBLIC bool switchSecondaryInput(const std::string& accountId, +LIBJAMI_PUBLIC bool switchSecondaryInput(const std::string& accountId, const std::string& confId, const std::string& resource); /* Instant messaging */ -DRING_PUBLIC void sendTextMessage(const std::string& accountId, +LIBJAMI_PUBLIC void sendTextMessage(const std::string& accountId, const std::string& callId, const std::map& messages, const std::string& from, bool isMixed); // Call signal type definitions -struct DRING_PUBLIC CallSignal +struct LIBJAMI_PUBLIC CallSignal { - struct DRING_PUBLIC StateChange + struct LIBJAMI_PUBLIC StateChange { constexpr static const char* name = "StateChange"; using cb_type = void(const std::string&, const std::string&, const std::string&, int); }; - struct DRING_PUBLIC TransferFailed + struct LIBJAMI_PUBLIC TransferFailed { constexpr static const char* name = "TransferFailed"; using cb_type = void(void); }; - struct DRING_PUBLIC TransferSucceeded + struct LIBJAMI_PUBLIC TransferSucceeded { constexpr static const char* name = "TransferSucceeded"; using cb_type = void(void); }; - struct DRING_PUBLIC RecordPlaybackStopped + struct LIBJAMI_PUBLIC RecordPlaybackStopped { constexpr static const char* name = "RecordPlaybackStopped"; using cb_type = void(const std::string&); }; - struct DRING_PUBLIC VoiceMailNotify + struct LIBJAMI_PUBLIC VoiceMailNotify { constexpr static const char* name = "VoiceMailNotify"; using cb_type = void(const std::string&, int32_t, int32_t, int32_t); }; - struct DRING_PUBLIC IncomingMessage + struct LIBJAMI_PUBLIC IncomingMessage { constexpr static const char* name = "IncomingMessage"; using cb_type = void(const std::string&, @@ -230,12 +230,12 @@ struct DRING_PUBLIC CallSignal const std::string&, const std::map&); }; - struct DRING_PUBLIC IncomingCall + struct LIBJAMI_PUBLIC IncomingCall { constexpr static const char* name = "IncomingCall"; using cb_type = void(const std::string&, const std::string&, const std::string&); }; - struct DRING_PUBLIC IncomingCallWithMedia + struct LIBJAMI_PUBLIC IncomingCallWithMedia { constexpr static const char* name = "IncomingCallWithMedia"; using cb_type = void(const std::string&, @@ -243,86 +243,86 @@ struct DRING_PUBLIC CallSignal const std::string&, const std::vector>&); }; - struct DRING_PUBLIC MediaChangeRequested + struct LIBJAMI_PUBLIC MediaChangeRequested { constexpr static const char* name = "MediaChangeRequested"; using cb_type = void(const std::string&, const std::string&, const std::vector>&); }; - struct DRING_PUBLIC RecordPlaybackFilepath + struct LIBJAMI_PUBLIC RecordPlaybackFilepath { constexpr static const char* name = "RecordPlaybackFilepath"; using cb_type = void(const std::string&, const std::string&); }; - struct DRING_PUBLIC ConferenceCreated + struct LIBJAMI_PUBLIC ConferenceCreated { constexpr static const char* name = "ConferenceCreated"; using cb_type = void(const std::string&, const std::string&); }; - struct DRING_PUBLIC ConferenceChanged + struct LIBJAMI_PUBLIC ConferenceChanged { constexpr static const char* name = "ConferenceChanged"; using cb_type = void(const std::string&, const std::string&, const std::string&); }; - struct DRING_PUBLIC UpdatePlaybackScale + struct LIBJAMI_PUBLIC UpdatePlaybackScale { constexpr static const char* name = "UpdatePlaybackScale"; using cb_type = void(const std::string&, unsigned, unsigned); }; - struct DRING_PUBLIC ConferenceRemoved + struct LIBJAMI_PUBLIC ConferenceRemoved { constexpr static const char* name = "ConferenceRemoved"; using cb_type = void(const std::string&, const std::string&); }; - struct DRING_PUBLIC RecordingStateChanged + struct LIBJAMI_PUBLIC RecordingStateChanged { constexpr static const char* name = "RecordingStateChanged"; using cb_type = void(const std::string&, int); }; - struct DRING_PUBLIC RtcpReportReceived + struct LIBJAMI_PUBLIC RtcpReportReceived { constexpr static const char* name = "RtcpReportReceived"; using cb_type = void(const std::string&, const std::map&); }; - struct DRING_PUBLIC PeerHold + struct LIBJAMI_PUBLIC PeerHold { constexpr static const char* name = "PeerHold"; using cb_type = void(const std::string&, bool); }; - struct DRING_PUBLIC VideoMuted + struct LIBJAMI_PUBLIC VideoMuted { constexpr static const char* name = "VideoMuted"; using cb_type = void(const std::string&, bool); }; - struct DRING_PUBLIC AudioMuted + struct LIBJAMI_PUBLIC AudioMuted { constexpr static const char* name = "AudioMuted"; using cb_type = void(const std::string&, bool); }; - struct DRING_PUBLIC SmartInfo + struct LIBJAMI_PUBLIC SmartInfo { constexpr static const char* name = "SmartInfo"; using cb_type = void(const std::map&); }; - struct DRING_PUBLIC ConnectionUpdate + struct LIBJAMI_PUBLIC ConnectionUpdate { constexpr static const char* name = "ConnectionUpdate"; using cb_type = void(const std::string&, int); }; - struct DRING_PUBLIC OnConferenceInfosUpdated + struct LIBJAMI_PUBLIC OnConferenceInfosUpdated { constexpr static const char* name = "OnConferenceInfosUpdated"; using cb_type = void(const std::string&, const std::vector>&); }; - struct DRING_PUBLIC RemoteRecordingChanged + struct LIBJAMI_PUBLIC RemoteRecordingChanged { constexpr static const char* name = "RemoteRecordingChanged"; using cb_type = void(const std::string&, const std::string&, bool); }; // Report media negotiation status - struct DRING_PUBLIC MediaNegotiationStatus + struct LIBJAMI_PUBLIC MediaNegotiationStatus { constexpr static const char* name = "MediaNegotiationStatus"; using cb_type = void(const std::string&, @@ -331,6 +331,6 @@ struct DRING_PUBLIC CallSignal }; }; -} // namespace DRing +} // namespace libjami -#endif // DRING_CALLMANAGERI_H +#endif // LIBJAMI_CALLMANAGERI_H diff --git a/src/jami/configurationmanager_interface.h b/src/jami/configurationmanager_interface.h index b5ada18e3..b9d79de49 100644 --- a/src/jami/configurationmanager_interface.h +++ b/src/jami/configurationmanager_interface.h @@ -41,206 +41,206 @@ #include #endif -namespace DRing { +namespace libjami { -[[deprecated("Replaced by registerSignalHandlers")]] DRING_PUBLIC void registerConfHandlers( +[[deprecated("Replaced by registerSignalHandlers")]] LIBJAMI_PUBLIC void registerConfHandlers( const std::map>&); -struct DRING_PUBLIC Message +struct LIBJAMI_PUBLIC Message { std::string from; std::map payloads; uint64_t received; }; -DRING_PUBLIC std::map getAccountDetails(const std::string& accountID); -DRING_PUBLIC std::map getVolatileAccountDetails( +LIBJAMI_PUBLIC std::map getAccountDetails(const std::string& accountID); +LIBJAMI_PUBLIC std::map getVolatileAccountDetails( const std::string& accountID); -DRING_PUBLIC void setAccountDetails(const std::string& accountID, +LIBJAMI_PUBLIC void setAccountDetails(const std::string& accountID, const std::map& details); -DRING_PUBLIC void setAccountActive(const std::string& accountID, +LIBJAMI_PUBLIC void setAccountActive(const std::string& accountID, bool active, bool shutdownConnections = false); -DRING_PUBLIC std::map getAccountTemplate(const std::string& accountType); -DRING_PUBLIC std::string addAccount(const std::map& details, +LIBJAMI_PUBLIC std::map getAccountTemplate(const std::string& accountType); +LIBJAMI_PUBLIC std::string addAccount(const std::map& details, const std::string& accountID = {}); -DRING_PUBLIC void monitor(bool continuous); -DRING_PUBLIC bool exportOnRing(const std::string& accountID, const std::string& password); -DRING_PUBLIC bool exportToFile(const std::string& accountID, +LIBJAMI_PUBLIC void monitor(bool continuous); +LIBJAMI_PUBLIC bool exportOnRing(const std::string& accountID, const std::string& password); +LIBJAMI_PUBLIC bool exportToFile(const std::string& accountID, const std::string& destinationPath, const std::string& password = {}); -DRING_PUBLIC bool revokeDevice(const std::string& accountID, +LIBJAMI_PUBLIC bool revokeDevice(const std::string& accountID, const std::string& password, const std::string& deviceID); -DRING_PUBLIC std::map getKnownRingDevices(const std::string& accountID); -DRING_PUBLIC bool changeAccountPassword(const std::string& accountID, +LIBJAMI_PUBLIC std::map getKnownRingDevices(const std::string& accountID); +LIBJAMI_PUBLIC bool changeAccountPassword(const std::string& accountID, const std::string& password_old, const std::string& password_new); -DRING_PUBLIC bool isPasswordValid(const std::string& accountID, const std::string& password); +LIBJAMI_PUBLIC bool isPasswordValid(const std::string& accountID, const std::string& password); -DRING_PUBLIC bool lookupName(const std::string& account, +LIBJAMI_PUBLIC bool lookupName(const std::string& account, const std::string& nameserver, const std::string& name); -DRING_PUBLIC bool lookupAddress(const std::string& account, +LIBJAMI_PUBLIC bool lookupAddress(const std::string& account, const std::string& nameserver, const std::string& address); -DRING_PUBLIC bool registerName(const std::string& account, +LIBJAMI_PUBLIC bool registerName(const std::string& account, const std::string& password, const std::string& name); -DRING_PUBLIC bool searchUser(const std::string& account, const std::string& query); +LIBJAMI_PUBLIC bool searchUser(const std::string& account, const std::string& query); -DRING_PUBLIC void removeAccount(const std::string& accountID); -DRING_PUBLIC std::vector getAccountList(); -DRING_PUBLIC void sendRegister(const std::string& accountID, bool enable); -DRING_PUBLIC void registerAllAccounts(void); -DRING_PUBLIC uint64_t sendAccountTextMessage(const std::string& accountID, +LIBJAMI_PUBLIC void removeAccount(const std::string& accountID); +LIBJAMI_PUBLIC std::vector getAccountList(); +LIBJAMI_PUBLIC void sendRegister(const std::string& accountID, bool enable); +LIBJAMI_PUBLIC void registerAllAccounts(void); +LIBJAMI_PUBLIC uint64_t sendAccountTextMessage(const std::string& accountID, const std::string& to, const std::map& payloads); -DRING_PUBLIC bool cancelMessage(const std::string& accountID, uint64_t message); -DRING_PUBLIC std::vector getLastMessages(const std::string& accountID, +LIBJAMI_PUBLIC bool cancelMessage(const std::string& accountID, uint64_t message); +LIBJAMI_PUBLIC std::vector getLastMessages(const std::string& accountID, const uint64_t& base_timestamp); -DRING_PUBLIC std::map getNearbyPeers(const std::string& accountID); -DRING_PUBLIC int getMessageStatus(uint64_t id); -DRING_PUBLIC int getMessageStatus(const std::string& accountID, uint64_t id); -DRING_PUBLIC void setIsComposing(const std::string& accountID, +LIBJAMI_PUBLIC std::map getNearbyPeers(const std::string& accountID); +LIBJAMI_PUBLIC int getMessageStatus(uint64_t id); +LIBJAMI_PUBLIC int getMessageStatus(const std::string& accountID, uint64_t id); +LIBJAMI_PUBLIC void setIsComposing(const std::string& accountID, const std::string& conversationUri, bool isWriting); -DRING_PUBLIC bool setMessageDisplayed(const std::string& accountID, +LIBJAMI_PUBLIC bool setMessageDisplayed(const std::string& accountID, const std::string& conversationUri, const std::string& messageId, int status); -DRING_PUBLIC std::vector getCodecList(); -DRING_PUBLIC std::vector getSupportedTlsMethod(); -DRING_PUBLIC std::vector getSupportedCiphers(const std::string& accountID); -DRING_PUBLIC std::map getCodecDetails(const std::string& accountID, +LIBJAMI_PUBLIC std::vector getCodecList(); +LIBJAMI_PUBLIC std::vector getSupportedTlsMethod(); +LIBJAMI_PUBLIC std::vector getSupportedCiphers(const std::string& accountID); +LIBJAMI_PUBLIC std::map getCodecDetails(const std::string& accountID, const unsigned& codecId); -DRING_PUBLIC bool setCodecDetails(const std::string& accountID, +LIBJAMI_PUBLIC bool setCodecDetails(const std::string& accountID, const unsigned& codecId, const std::map& details); -DRING_PUBLIC std::vector getActiveCodecList(const std::string& accountID); +LIBJAMI_PUBLIC std::vector getActiveCodecList(const std::string& accountID); -DRING_PUBLIC void setActiveCodecList(const std::string& accountID, +LIBJAMI_PUBLIC void setActiveCodecList(const std::string& accountID, const std::vector& list); -DRING_PUBLIC std::vector getAudioPluginList(); -DRING_PUBLIC void setAudioPlugin(const std::string& audioPlugin); -DRING_PUBLIC std::vector getAudioOutputDeviceList(); -DRING_PUBLIC void setAudioOutputDevice(int32_t index); -DRING_PUBLIC void startAudio(); -DRING_PUBLIC void setAudioInputDevice(int32_t index); -DRING_PUBLIC void setAudioRingtoneDevice(int32_t index); -DRING_PUBLIC std::vector getAudioInputDeviceList(); -DRING_PUBLIC std::vector getCurrentAudioDevicesIndex(); -DRING_PUBLIC int32_t getAudioInputDeviceIndex(const std::string& name); -DRING_PUBLIC int32_t getAudioOutputDeviceIndex(const std::string& name); -DRING_PUBLIC std::string getCurrentAudioOutputPlugin(); -DRING_PUBLIC bool getNoiseSuppressState(); -DRING_PUBLIC void setNoiseSuppressState(bool state); +LIBJAMI_PUBLIC std::vector getAudioPluginList(); +LIBJAMI_PUBLIC void setAudioPlugin(const std::string& audioPlugin); +LIBJAMI_PUBLIC std::vector getAudioOutputDeviceList(); +LIBJAMI_PUBLIC void setAudioOutputDevice(int32_t index); +LIBJAMI_PUBLIC void startAudio(); +LIBJAMI_PUBLIC void setAudioInputDevice(int32_t index); +LIBJAMI_PUBLIC void setAudioRingtoneDevice(int32_t index); +LIBJAMI_PUBLIC std::vector getAudioInputDeviceList(); +LIBJAMI_PUBLIC std::vector getCurrentAudioDevicesIndex(); +LIBJAMI_PUBLIC int32_t getAudioInputDeviceIndex(const std::string& name); +LIBJAMI_PUBLIC int32_t getAudioOutputDeviceIndex(const std::string& name); +LIBJAMI_PUBLIC std::string getCurrentAudioOutputPlugin(); +LIBJAMI_PUBLIC bool getNoiseSuppressState(); +LIBJAMI_PUBLIC void setNoiseSuppressState(bool state); -DRING_PUBLIC bool isAgcEnabled(); -DRING_PUBLIC void setAgcState(bool enabled); +LIBJAMI_PUBLIC bool isAgcEnabled(); +LIBJAMI_PUBLIC void setAgcState(bool enabled); -DRING_PUBLIC void muteDtmf(bool mute); -DRING_PUBLIC bool isDtmfMuted(); +LIBJAMI_PUBLIC void muteDtmf(bool mute); +LIBJAMI_PUBLIC bool isDtmfMuted(); -DRING_PUBLIC bool isCaptureMuted(); -DRING_PUBLIC void muteCapture(bool mute); -DRING_PUBLIC bool isPlaybackMuted(); -DRING_PUBLIC void mutePlayback(bool mute); -DRING_PUBLIC bool isRingtoneMuted(); -DRING_PUBLIC void muteRingtone(bool mute); +LIBJAMI_PUBLIC bool isCaptureMuted(); +LIBJAMI_PUBLIC void muteCapture(bool mute); +LIBJAMI_PUBLIC bool isPlaybackMuted(); +LIBJAMI_PUBLIC void mutePlayback(bool mute); +LIBJAMI_PUBLIC bool isRingtoneMuted(); +LIBJAMI_PUBLIC void muteRingtone(bool mute); -DRING_PUBLIC std::vector getSupportedAudioManagers(); -DRING_PUBLIC std::string getAudioManager(); -DRING_PUBLIC bool setAudioManager(const std::string& api); +LIBJAMI_PUBLIC std::vector getSupportedAudioManagers(); +LIBJAMI_PUBLIC std::string getAudioManager(); +LIBJAMI_PUBLIC bool setAudioManager(const std::string& api); -DRING_PUBLIC std::string getRecordPath(); -DRING_PUBLIC void setRecordPath(const std::string& recPath); -DRING_PUBLIC bool getIsAlwaysRecording(); -DRING_PUBLIC void setIsAlwaysRecording(bool rec); -DRING_PUBLIC bool getRecordPreview(); -DRING_PUBLIC void setRecordPreview(bool rec); -DRING_PUBLIC int getRecordQuality(); -DRING_PUBLIC void setRecordQuality(int quality); +LIBJAMI_PUBLIC std::string getRecordPath(); +LIBJAMI_PUBLIC void setRecordPath(const std::string& recPath); +LIBJAMI_PUBLIC bool getIsAlwaysRecording(); +LIBJAMI_PUBLIC void setIsAlwaysRecording(bool rec); +LIBJAMI_PUBLIC bool getRecordPreview(); +LIBJAMI_PUBLIC void setRecordPreview(bool rec); +LIBJAMI_PUBLIC int getRecordQuality(); +LIBJAMI_PUBLIC void setRecordQuality(int quality); -DRING_PUBLIC void setHistoryLimit(int32_t days); -DRING_PUBLIC int32_t getHistoryLimit(); +LIBJAMI_PUBLIC void setHistoryLimit(int32_t days); +LIBJAMI_PUBLIC int32_t getHistoryLimit(); -DRING_PUBLIC void setRingingTimeout(int32_t timeout); -DRING_PUBLIC int32_t getRingingTimeout(); +LIBJAMI_PUBLIC void setRingingTimeout(int32_t timeout); +LIBJAMI_PUBLIC int32_t getRingingTimeout(); -DRING_PUBLIC void setAccountsOrder(const std::string& order); +LIBJAMI_PUBLIC void setAccountsOrder(const std::string& order); -DRING_PUBLIC std::vector> getCredentials( +LIBJAMI_PUBLIC std::vector> getCredentials( const std::string& accountID); -DRING_PUBLIC void setCredentials(const std::string& accountID, +LIBJAMI_PUBLIC void setCredentials(const std::string& accountID, const std::vector>& details); -DRING_PUBLIC std::string getAddrFromInterfaceName(const std::string& iface); +LIBJAMI_PUBLIC std::string getAddrFromInterfaceName(const std::string& iface); -DRING_PUBLIC std::vector getAllIpInterface(); -DRING_PUBLIC std::vector getAllIpInterfaceByName(); +LIBJAMI_PUBLIC std::vector getAllIpInterface(); +LIBJAMI_PUBLIC std::vector getAllIpInterfaceByName(); -DRING_PUBLIC void setVolume(const std::string& device, double value); -DRING_PUBLIC double getVolume(const std::string& device); +LIBJAMI_PUBLIC void setVolume(const std::string& device, double value); +LIBJAMI_PUBLIC double getVolume(const std::string& device); /* * Security */ -DRING_PUBLIC std::map validateCertificate(const std::string& accountId, +LIBJAMI_PUBLIC std::map validateCertificate(const std::string& accountId, const std::string& certificate); -DRING_PUBLIC std::map validateCertificatePath( +LIBJAMI_PUBLIC std::map validateCertificatePath( const std::string& accountId, const std::string& certificatePath, const std::string& privateKey, const std::string& privateKeyPassword, const std::string& caList); -DRING_PUBLIC std::map getCertificateDetails(const std::string& certificate); -DRING_PUBLIC std::map getCertificateDetailsPath( +LIBJAMI_PUBLIC std::map getCertificateDetails(const std::string& certificate); +LIBJAMI_PUBLIC std::map getCertificateDetailsPath( const std::string& certificatePath, const std::string& privateKey, const std::string& privateKeyPassword); -DRING_PUBLIC std::vector getPinnedCertificates(); +LIBJAMI_PUBLIC std::vector getPinnedCertificates(); -DRING_PUBLIC std::vector pinCertificate(const std::vector& certificate, +LIBJAMI_PUBLIC std::vector pinCertificate(const std::vector& certificate, bool local); -DRING_PUBLIC bool unpinCertificate(const std::string& certId); +LIBJAMI_PUBLIC bool unpinCertificate(const std::string& certId); -DRING_PUBLIC void pinCertificatePath(const std::string& path); -DRING_PUBLIC unsigned unpinCertificatePath(const std::string& path); +LIBJAMI_PUBLIC void pinCertificatePath(const std::string& path); +LIBJAMI_PUBLIC unsigned unpinCertificatePath(const std::string& path); -DRING_PUBLIC bool pinRemoteCertificate(const std::string& accountId, const std::string& certId); -DRING_PUBLIC bool setCertificateStatus(const std::string& account, +LIBJAMI_PUBLIC bool pinRemoteCertificate(const std::string& accountId, const std::string& certId); +LIBJAMI_PUBLIC bool setCertificateStatus(const std::string& account, const std::string& certId, const std::string& status); -DRING_PUBLIC std::vector getCertificatesByStatus(const std::string& account, +LIBJAMI_PUBLIC std::vector getCertificatesByStatus(const std::string& account, const std::string& status); /* contact requests */ -DRING_PUBLIC std::vector> getTrustRequests( +LIBJAMI_PUBLIC std::vector> getTrustRequests( const std::string& accountId); -DRING_PUBLIC bool acceptTrustRequest(const std::string& accountId, const std::string& from); -DRING_PUBLIC bool discardTrustRequest(const std::string& accountId, const std::string& from); -DRING_PUBLIC void sendTrustRequest(const std::string& accountId, +LIBJAMI_PUBLIC bool acceptTrustRequest(const std::string& accountId, const std::string& from); +LIBJAMI_PUBLIC bool discardTrustRequest(const std::string& accountId, const std::string& from); +LIBJAMI_PUBLIC void sendTrustRequest(const std::string& accountId, const std::string& to, const std::vector& payload = {}); /* Contacts */ -DRING_PUBLIC void addContact(const std::string& accountId, const std::string& uri); -DRING_PUBLIC void removeContact(const std::string& accountId, const std::string& uri, bool ban); -DRING_PUBLIC std::map getContactDetails(const std::string& accountId, +LIBJAMI_PUBLIC void addContact(const std::string& accountId, const std::string& uri); +LIBJAMI_PUBLIC void removeContact(const std::string& accountId, const std::string& uri, bool ban); +LIBJAMI_PUBLIC std::map getContactDetails(const std::string& accountId, const std::string& uri); -DRING_PUBLIC std::vector> getContacts( +LIBJAMI_PUBLIC std::vector> getContacts( const std::string& accountId); /* * Network connectivity */ -DRING_PUBLIC void connectivityChanged(); +LIBJAMI_PUBLIC void connectivityChanged(); /* Dht proxy */ @@ -249,18 +249,18 @@ DRING_PUBLIC void connectivityChanged(); * If set, proxy clients will use push notifications. * Set to empty to disable push notifications. */ -DRING_PUBLIC void setPushNotificationToken(const std::string& pushDeviceToken); +LIBJAMI_PUBLIC void setPushNotificationToken(const std::string& pushDeviceToken); /** * Set the topic for ios * bundle_id for ios 14.5 and higher * bundle_id.voip for ios prior 14.5 */ -DRING_PUBLIC void setPushNotificationTopic(const std::string& topic); +LIBJAMI_PUBLIC void setPushNotificationTopic(const std::string& topic); /** * To be called by clients with relevant data when a push notification is received. */ -DRING_PUBLIC void pushNotificationReceived(const std::string& from, +LIBJAMI_PUBLIC void pushNotificationReceived(const std::string& from, const std::map& data); /** @@ -268,56 +268,56 @@ DRING_PUBLIC void pushNotificationReceived(const std::string& from, * * NOTE If @id is empty, returns true if at least 1 audio meter is enabled. */ -DRING_PUBLIC bool isAudioMeterActive(const std::string& id); +LIBJAMI_PUBLIC bool isAudioMeterActive(const std::string& id); /** * Enables/disables an audio meter for the specified @id. * * NOTE If @id is empty, applies to all ring buffers. */ -DRING_PUBLIC void setAudioMeterState(const std::string& id, bool state); +LIBJAMI_PUBLIC void setAudioMeterState(const std::string& id, bool state); /** * Add/remove default moderator for conferences */ -DRING_PUBLIC void setDefaultModerator(const std::string& accountID, +LIBJAMI_PUBLIC void setDefaultModerator(const std::string& accountID, const std::string& peerURI, bool state); /** * Get default moderators for an account */ -DRING_PUBLIC std::vector getDefaultModerators(const std::string& accountID); +LIBJAMI_PUBLIC std::vector getDefaultModerators(const std::string& accountID); /** * Enable/disable local moderators for conferences */ -DRING_PUBLIC void enableLocalModerators(const std::string& accountID, bool isModEnabled); +LIBJAMI_PUBLIC void enableLocalModerators(const std::string& accountID, bool isModEnabled); /** * Get local moderators state */ -DRING_PUBLIC bool isLocalModeratorsEnabled(const std::string& accountID); +LIBJAMI_PUBLIC bool isLocalModeratorsEnabled(const std::string& accountID); /** * Enable/disable all moderators for conferences */ -DRING_PUBLIC void setAllModerators(const std::string& accountID, bool allModerators); +LIBJAMI_PUBLIC void setAllModerators(const std::string& accountID, bool allModerators); /** * Get all moderators state */ -DRING_PUBLIC bool isAllModerators(const std::string& accountID); +LIBJAMI_PUBLIC bool isAllModerators(const std::string& accountID); -struct DRING_PUBLIC AudioSignal +struct LIBJAMI_PUBLIC AudioSignal { - struct DRING_PUBLIC DeviceEvent + struct LIBJAMI_PUBLIC DeviceEvent { constexpr static const char* name = "audioDeviceEvent"; using cb_type = void(void); }; // Linear audio level (between 0 and 1). To get level in dB: dB=20*log10(level) - struct DRING_PUBLIC AudioMeter + struct LIBJAMI_PUBLIC AudioMeter { constexpr static const char* name = "AudioMeter"; using cb_type = void(const std::string& id, float level); @@ -325,37 +325,37 @@ struct DRING_PUBLIC AudioSignal }; // Configuration signal type definitions -struct DRING_PUBLIC ConfigurationSignal +struct LIBJAMI_PUBLIC ConfigurationSignal { - struct DRING_PUBLIC VolumeChanged + struct LIBJAMI_PUBLIC VolumeChanged { constexpr static const char* name = "VolumeChanged"; using cb_type = void(const std::string& /*device*/, double /*value*/); }; - struct DRING_PUBLIC AccountsChanged + struct LIBJAMI_PUBLIC AccountsChanged { constexpr static const char* name = "AccountsChanged"; using cb_type = void(void); }; - struct DRING_PUBLIC Error + struct LIBJAMI_PUBLIC Error { constexpr static const char* name = "Error"; using cb_type = void(int /*alert*/); }; // TODO: move those to AccountSignal in next API breakage - struct DRING_PUBLIC AccountDetailsChanged + struct LIBJAMI_PUBLIC AccountDetailsChanged { constexpr static const char* name = "AccountDetailsChanged"; using cb_type = void(const std::string& /*account_id*/, const std::map& /* details */); }; - struct DRING_PUBLIC StunStatusFailed + struct LIBJAMI_PUBLIC StunStatusFailed { constexpr static const char* name = "StunStatusFailed"; using cb_type = void(const std::string& /*account_id*/); }; - struct DRING_PUBLIC RegistrationStateChanged + struct LIBJAMI_PUBLIC RegistrationStateChanged { constexpr static const char* name = "RegistrationStateChanged"; using cb_type = void(const std::string& /*account_id*/, @@ -363,13 +363,13 @@ struct DRING_PUBLIC ConfigurationSignal int /*detailsCode*/, const std::string& /*detailsStr*/); }; - struct DRING_PUBLIC VolatileDetailsChanged + struct LIBJAMI_PUBLIC VolatileDetailsChanged { constexpr static const char* name = "VolatileDetailsChanged"; using cb_type = void(const std::string& /*account_id*/, const std::map& /* details */); }; - struct DRING_PUBLIC IncomingAccountMessage + struct LIBJAMI_PUBLIC IncomingAccountMessage { constexpr static const char* name = "IncomingAccountMessage"; using cb_type = void(const std::string& /*account_id*/, @@ -377,7 +377,7 @@ struct DRING_PUBLIC ConfigurationSignal const std::string& /*message_id*/, const std::map& /*payloads*/); }; - struct DRING_PUBLIC AccountMessageStatusChanged + struct LIBJAMI_PUBLIC AccountMessageStatusChanged { constexpr static const char* name = "AccountMessageStatusChanged"; using cb_type = void(const std::string& /*account_id*/, @@ -386,14 +386,14 @@ struct DRING_PUBLIC ConfigurationSignal const std::string& /*message_id*/, int /*state*/); }; - struct DRING_PUBLIC ProfileReceived + struct LIBJAMI_PUBLIC ProfileReceived { constexpr static const char* name = "ProfileReceived"; using cb_type = void(const std::string& /*account_id*/, const std::string& /*from*/, const std::string& /*vcard*/); }; - struct DRING_PUBLIC ComposingStatusChanged + struct LIBJAMI_PUBLIC ComposingStatusChanged { constexpr static const char* name = "ComposingStatusChanged"; using cb_type = void(const std::string& /*account_id*/, @@ -401,7 +401,7 @@ struct DRING_PUBLIC ConfigurationSignal const std::string& /*from*/, int /*status*/); }; - struct DRING_PUBLIC IncomingTrustRequest + struct LIBJAMI_PUBLIC IncomingTrustRequest { constexpr static const char* name = "IncomingTrustRequest"; using cb_type = void(const std::string& /*account_id*/, @@ -410,37 +410,37 @@ struct DRING_PUBLIC ConfigurationSignal const std::vector& payload, time_t received); }; - struct DRING_PUBLIC ContactAdded + struct LIBJAMI_PUBLIC ContactAdded { constexpr static const char* name = "ContactAdded"; using cb_type = void(const std::string& /*account_id*/, const std::string& /*uri*/, bool confirmed); }; - struct DRING_PUBLIC ContactRemoved + struct LIBJAMI_PUBLIC ContactRemoved { constexpr static const char* name = "ContactRemoved"; using cb_type = void(const std::string& /*account_id*/, const std::string& /*uri*/, bool banned); }; - struct DRING_PUBLIC ExportOnRingEnded + struct LIBJAMI_PUBLIC ExportOnRingEnded { constexpr static const char* name = "ExportOnRingEnded"; using cb_type = void(const std::string& /*account_id*/, int state, const std::string& pin); }; - struct DRING_PUBLIC NameRegistrationEnded + struct LIBJAMI_PUBLIC NameRegistrationEnded { constexpr static const char* name = "NameRegistrationEnded"; using cb_type = void(const std::string& /*account_id*/, int state, const std::string& name); }; - struct DRING_PUBLIC KnownDevicesChanged + struct LIBJAMI_PUBLIC KnownDevicesChanged { constexpr static const char* name = "KnownDevicesChanged"; using cb_type = void(const std::string& /*account_id*/, const std::map& devices); }; - struct DRING_PUBLIC RegisteredNameFound + struct LIBJAMI_PUBLIC RegisteredNameFound { constexpr static const char* name = "RegisteredNameFound"; using cb_type = void(const std::string& /*account_id*/, @@ -448,7 +448,7 @@ struct DRING_PUBLIC ConfigurationSignal const std::string& /*address*/, const std::string& /*name*/); }; - struct DRING_PUBLIC UserSearchEnded + struct LIBJAMI_PUBLIC UserSearchEnded { constexpr static const char* name = "UserSearchEnded"; using cb_type = void(const std::string& /*account_id*/, @@ -456,47 +456,47 @@ struct DRING_PUBLIC ConfigurationSignal const std::string& /*query*/, const std::vector>& /*results*/); }; - struct DRING_PUBLIC CertificatePinned + struct LIBJAMI_PUBLIC CertificatePinned { constexpr static const char* name = "CertificatePinned"; using cb_type = void(const std::string& /*certId*/); }; - struct DRING_PUBLIC CertificatePathPinned + struct LIBJAMI_PUBLIC CertificatePathPinned { constexpr static const char* name = "CertificatePathPinned"; using cb_type = void(const std::string& /*path*/, const std::vector& /*certId*/); }; - struct DRING_PUBLIC CertificateExpired + struct LIBJAMI_PUBLIC CertificateExpired { constexpr static const char* name = "CertificateExpired"; using cb_type = void(const std::string& /*certId*/); }; - struct DRING_PUBLIC CertificateStateChanged + struct LIBJAMI_PUBLIC CertificateStateChanged { constexpr static const char* name = "CertificateStateChanged"; using cb_type = void(const std::string& /*account_id*/, const std::string& /*certId*/, const std::string& /*state*/); }; - struct DRING_PUBLIC MediaParametersChanged + struct LIBJAMI_PUBLIC MediaParametersChanged { constexpr static const char* name = "MediaParametersChanged"; using cb_type = void(const std::string& /*accountId*/); }; - struct DRING_PUBLIC MigrationEnded + struct LIBJAMI_PUBLIC MigrationEnded { constexpr static const char* name = "MigrationEnded"; using cb_type = void(const std::string& /*accountId*/, const std::string& /*state*/); }; - struct DRING_PUBLIC DeviceRevocationEnded + struct LIBJAMI_PUBLIC DeviceRevocationEnded { constexpr static const char* name = "DeviceRevocationEnded"; using cb_type = void(const std::string& /*accountId*/, const std::string& /*device*/, int /*status*/); }; - struct DRING_PUBLIC AccountProfileReceived + struct LIBJAMI_PUBLIC AccountProfileReceived { constexpr static const char* name = "AccountProfileReceived"; using cb_type = void(const std::string& /*accountId*/, @@ -508,39 +508,39 @@ struct DRING_PUBLIC ConfigurationSignal * information only accessible through their respective platform APIs */ #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) - struct DRING_PUBLIC GetHardwareAudioFormat + struct LIBJAMI_PUBLIC GetHardwareAudioFormat { constexpr static const char* name = "GetHardwareAudioFormat"; using cb_type = void(std::vector* /* params_ret */); }; #endif #if defined(__ANDROID__) || defined(RING_UWP) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) - struct DRING_PUBLIC GetAppDataPath + struct LIBJAMI_PUBLIC GetAppDataPath { constexpr static const char* name = "GetAppDataPath"; using cb_type = void(const std::string& name, std::vector* /* path_ret */); }; - struct DRING_PUBLIC GetDeviceName + struct LIBJAMI_PUBLIC GetDeviceName { constexpr static const char* name = "GetDeviceName"; using cb_type = void(std::vector* /* path_ret */); }; #endif - struct DRING_PUBLIC HardwareDecodingChanged + struct LIBJAMI_PUBLIC HardwareDecodingChanged { constexpr static const char* name = "HardwareDecodingChanged"; using cb_type = void(bool /* state */); }; - struct DRING_PUBLIC HardwareEncodingChanged + struct LIBJAMI_PUBLIC HardwareEncodingChanged { constexpr static const char* name = "HardwareEncodingChanged"; using cb_type = void(bool /* state */); }; - struct DRING_PUBLIC MessageSend + struct LIBJAMI_PUBLIC MessageSend { constexpr static const char* name = "MessageSend"; using cb_type = void(const std::string&); }; }; -} // namespace DRing +} // namespace libjami diff --git a/src/jami/conversation_interface.h b/src/jami/conversation_interface.h index 404b7332c..011af5d64 100644 --- a/src/jami/conversation_interface.h +++ b/src/jami/conversation_interface.h @@ -18,8 +18,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_CONVERSATIONI_H -#define DRING_CONVERSATIONI_H +#ifndef LIBJAMI_CONVERSATIONI_H +#define LIBJAMI_CONVERSATIONI_H #include "def.h" @@ -29,62 +29,62 @@ #include "jami.h" -namespace DRing { +namespace libjami { // Conversation management -DRING_PUBLIC std::string startConversation(const std::string& accountId); -DRING_PUBLIC void acceptConversationRequest(const std::string& accountId, +LIBJAMI_PUBLIC std::string startConversation(const std::string& accountId); +LIBJAMI_PUBLIC void acceptConversationRequest(const std::string& accountId, const std::string& conversationId); -DRING_PUBLIC void declineConversationRequest(const std::string& accountId, +LIBJAMI_PUBLIC void declineConversationRequest(const std::string& accountId, const std::string& conversationId); -DRING_PUBLIC bool removeConversation(const std::string& accountId, +LIBJAMI_PUBLIC bool removeConversation(const std::string& accountId, const std::string& conversationId); -DRING_PUBLIC std::vector getConversations(const std::string& accountId); -DRING_PUBLIC std::vector> getConversationRequests( +LIBJAMI_PUBLIC std::vector getConversations(const std::string& accountId); +LIBJAMI_PUBLIC std::vector> getConversationRequests( const std::string& accountId); // Conversation's infos management -DRING_PUBLIC void updateConversationInfos(const std::string& accountId, +LIBJAMI_PUBLIC void updateConversationInfos(const std::string& accountId, const std::string& conversationId, const std::map& infos); -DRING_PUBLIC std::map conversationInfos(const std::string& accountId, +LIBJAMI_PUBLIC std::map conversationInfos(const std::string& accountId, const std::string& conversationId); -DRING_PUBLIC void setConversationPreferences(const std::string& accountId, +LIBJAMI_PUBLIC void setConversationPreferences(const std::string& accountId, const std::string& conversationId, const std::map& prefs); -DRING_PUBLIC std::map getConversationPreferences( +LIBJAMI_PUBLIC std::map getConversationPreferences( const std::string& accountId, const std::string& conversationId); // Member management -DRING_PUBLIC void addConversationMember(const std::string& accountId, +LIBJAMI_PUBLIC void addConversationMember(const std::string& accountId, const std::string& conversationId, const std::string& contactUri); -DRING_PUBLIC void removeConversationMember(const std::string& accountId, +LIBJAMI_PUBLIC void removeConversationMember(const std::string& accountId, const std::string& conversationId, const std::string& contactUri); -DRING_PUBLIC std::vector> getConversationMembers( +LIBJAMI_PUBLIC std::vector> getConversationMembers( const std::string& accountId, const std::string& conversationId); // Message send/load -DRING_PUBLIC void sendMessage(const std::string& accountId, +LIBJAMI_PUBLIC void sendMessage(const std::string& accountId, const std::string& conversationId, const std::string& message, const std::string& replyTo, const int32_t& flag = 0); -DRING_PUBLIC uint32_t loadConversationMessages(const std::string& accountId, +LIBJAMI_PUBLIC uint32_t loadConversationMessages(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); -DRING_PUBLIC uint32_t loadConversationUntil(const std::string& accountId, +LIBJAMI_PUBLIC uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, const std::string& toMessage); -DRING_PUBLIC uint32_t countInteractions(const std::string& accountId, +LIBJAMI_PUBLIC uint32_t countInteractions(const std::string& accountId, const std::string& conversationId, const std::string& toId, const std::string& fromId, const std::string& authorUri); -DRING_PUBLIC uint32_t searchConversation(const std::string& accountId, +LIBJAMI_PUBLIC uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, const std::string& author, const std::string& lastId, @@ -94,9 +94,9 @@ DRING_PUBLIC uint32_t searchConversation(const std::string& accountId, const int64_t& before, const uint32_t& maxResult); -struct DRING_PUBLIC ConversationSignal +struct LIBJAMI_PUBLIC ConversationSignal { - struct DRING_PUBLIC ConversationLoaded + struct LIBJAMI_PUBLIC ConversationLoaded { constexpr static const char* name = "ConversationLoaded"; using cb_type = void(uint32_t /* id */, @@ -104,7 +104,7 @@ struct DRING_PUBLIC ConversationSignal const std::string& /* conversationId */, std::vector> /*messages*/); }; - struct DRING_PUBLIC MessagesFound + struct LIBJAMI_PUBLIC MessagesFound { constexpr static const char* name = "MessagesFound"; using cb_type = void(uint32_t /* id */, @@ -112,46 +112,46 @@ struct DRING_PUBLIC ConversationSignal const std::string& /* conversationId */, std::vector> /*messages*/); }; - struct DRING_PUBLIC MessageReceived + struct LIBJAMI_PUBLIC MessageReceived { constexpr static const char* name = "MessageReceived"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*message*/); }; - struct DRING_PUBLIC ConversationProfileUpdated + struct LIBJAMI_PUBLIC ConversationProfileUpdated { constexpr static const char* name = "ConversationProfileUpdated"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*profile*/); }; - struct DRING_PUBLIC ConversationRequestReceived + struct LIBJAMI_PUBLIC ConversationRequestReceived { constexpr static const char* name = "ConversationRequestReceived"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/); }; - struct DRING_PUBLIC ConversationRequestDeclined + struct LIBJAMI_PUBLIC ConversationRequestDeclined { constexpr static const char* name = "ConversationRequestDeclined"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */); }; - struct DRING_PUBLIC ConversationReady + struct LIBJAMI_PUBLIC ConversationReady { constexpr static const char* name = "ConversationReady"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */); }; - struct DRING_PUBLIC ConversationRemoved + struct LIBJAMI_PUBLIC ConversationRemoved { constexpr static const char* name = "ConversationRemoved"; using cb_type = void(const std::string& /*accountId*/, const std::string& /* conversationId */); }; - struct DRING_PUBLIC ConversationMemberEvent + struct LIBJAMI_PUBLIC ConversationMemberEvent { constexpr static const char* name = "ConversationMemberEvent"; using cb_type = void(const std::string& /*accountId*/, @@ -160,13 +160,13 @@ struct DRING_PUBLIC ConversationSignal int /* event 0 = add, 1 = joins, 2 = leave, 3 = banned */); }; - struct DRING_PUBLIC ConversationSyncFinished + struct LIBJAMI_PUBLIC ConversationSyncFinished { constexpr static const char* name = "ConversationSyncFinished"; using cb_type = void(const std::string& /*accountId*/); }; - struct DRING_PUBLIC CallConnectionRequest + struct LIBJAMI_PUBLIC CallConnectionRequest { constexpr static const char* name = "CallConnectionRequest"; using cb_type = void(const std::string& /*accountId*/, @@ -174,7 +174,7 @@ struct DRING_PUBLIC ConversationSignal bool hasVideo); }; - struct DRING_PUBLIC OnConversationError + struct LIBJAMI_PUBLIC OnConversationError { constexpr static const char* name = "OnConversationError"; using cb_type = void(const std::string& /*accountId*/, @@ -184,7 +184,7 @@ struct DRING_PUBLIC ConversationSignal }; // Preferences - struct DRING_PUBLIC ConversationPreferencesUpdated + struct LIBJAMI_PUBLIC ConversationPreferencesUpdated { constexpr static const char* name = "ConversationPreferencesUpdated"; using cb_type = void(const std::string& /*accountId*/, @@ -193,6 +193,6 @@ struct DRING_PUBLIC ConversationSignal }; }; -} // namespace DRing +} // namespace libjami -#endif // DRING_CONVERSATIONI_H +#endif // LIBJAMI_CONVERSATIONI_H diff --git a/src/jami/datatransfer_interface.h b/src/jami/datatransfer_interface.h index ac35be225..b2aaedbd7 100644 --- a/src/jami/datatransfer_interface.h +++ b/src/jami/datatransfer_interface.h @@ -18,8 +18,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_DATATRANSFERI_H -#define DRING_DATATRANSFERI_H +#ifndef LIBJAMI_DATATRANSFERI_H +#define LIBJAMI_DATATRANSFERI_H #include "def.h" @@ -31,14 +31,14 @@ #include #include -namespace DRing { +namespace libjami { -[[deprecated("Replaced by registerSignalHandlers")]] DRING_PUBLIC void registerDataXferHandlers( +[[deprecated("Replaced by registerSignalHandlers")]] LIBJAMI_PUBLIC void registerDataXferHandlers( const std::map>&); using DataTransferId = uint64_t; -enum class DRING_PUBLIC DataTransferEventCode : uint32_t { +enum class LIBJAMI_PUBLIC DataTransferEventCode : uint32_t { invalid = 0, created, unsupported, @@ -53,7 +53,7 @@ enum class DRING_PUBLIC DataTransferEventCode : uint32_t { timeout_expired, }; -enum class DRING_PUBLIC DataTransferError : uint32_t { +enum class LIBJAMI_PUBLIC DataTransferError : uint32_t { success = 0, unknown, io, @@ -61,11 +61,11 @@ enum class DRING_PUBLIC DataTransferError : uint32_t { }; /// Bit definition for DataTransferInfo.flags field -enum class DRING_PUBLIC DataTransferFlags { +enum class LIBJAMI_PUBLIC DataTransferFlags { direction = 0, ///< 0: outgoing, 1: incoming }; -struct DRING_PUBLIC DataTransferInfo +struct LIBJAMI_PUBLIC DataTransferInfo { std::string accountId; ///< Identifier of the emiter/receiver account DataTransferEventCode lastEvent { @@ -108,10 +108,10 @@ struct DRING_PUBLIC DataTransferInfo /// DataTransferEvent signal for such event. There is no reserved or special values on /// DataTransferId type. /// -DRING_PUBLIC DataTransferError sendFileLegacy(const DataTransferInfo& info, +LIBJAMI_PUBLIC DataTransferError sendFileLegacy(const DataTransferInfo& info, DataTransferId& tid) noexcept; -DRING_PUBLIC void sendFile(const std::string& accountId, +LIBJAMI_PUBLIC void sendFile(const std::string& accountId, const std::string& conversationId, const std::string& path, const std::string& displayName, @@ -130,7 +130,7 @@ DRING_PUBLIC void sendFile(const std::string& accountId, /// \return DataTransferError::invalid_argument if id is unknown. /// \note unknown \a id results to a no-op call. /// -DRING_PUBLIC DataTransferError acceptFileTransfer(const std::string& accountId, +LIBJAMI_PUBLIC DataTransferError acceptFileTransfer(const std::string& accountId, const std::string& fileId, const std::string& file_path) noexcept; @@ -142,7 +142,7 @@ DRING_PUBLIC DataTransferError acceptFileTransfer(const std::string& accountId, /// \param fileId /// \param path /// -DRING_PUBLIC bool downloadFile(const std::string& accountId, +LIBJAMI_PUBLIC bool downloadFile(const std::string& accountId, const std::string& conversationId, const std::string& interactionId, const std::string& fileId, @@ -162,7 +162,7 @@ DRING_PUBLIC bool downloadFile(const std::string& accountId, /// DataTransferError cancelDataTransfer(const std::string& accountId, const std::string& conversationId, - const std::string& fileId) noexcept DRING_PUBLIC; + const std::string& fileId) noexcept LIBJAMI_PUBLIC; /// Return some information on given data transfer. /// @@ -172,7 +172,7 @@ DataTransferError cancelDataTransfer(const std::string& accountId, /// \return DataTransferError::invalid_argument if id is unknown. /// \note \a info structure is in undefined state in case of error. /// -DRING_PUBLIC DataTransferError dataTransferInfo(const std::string& accountId, +LIBJAMI_PUBLIC DataTransferError dataTransferInfo(const std::string& accountId, const std::string& fileId, DataTransferInfo& info) noexcept; @@ -185,7 +185,7 @@ DRING_PUBLIC DataTransferError dataTransferInfo(const std::string& accountId, /// \return DataTransferError::success if \a total and \a progress is set with valid values. /// DataTransferError::invalid_argument if the id is unknown. /// -DRING_PUBLIC DataTransferError fileTransferInfo(const std::string& accountId, +LIBJAMI_PUBLIC DataTransferError fileTransferInfo(const std::string& accountId, const std::string& conversationId, const std::string& fileId, std::string& path, @@ -193,9 +193,9 @@ DRING_PUBLIC DataTransferError fileTransferInfo(const std::string& accountId, int64_t& progress) noexcept; // Signals -struct DRING_PUBLIC DataTransferSignal +struct LIBJAMI_PUBLIC DataTransferSignal { - struct DRING_PUBLIC DataTransferEvent + struct LIBJAMI_PUBLIC DataTransferEvent { constexpr static const char* name = "DataTransferEvent"; using cb_type = void(const std::string& accountId, @@ -206,6 +206,6 @@ struct DRING_PUBLIC DataTransferSignal }; }; -} // namespace DRing +} // namespace libjami -#endif // DRING_DATATRANSFERI_H +#endif // LIBJAMI_DATATRANSFERI_H diff --git a/src/jami/def.h b/src/jami/def.h index 2cd22990a..e20da8bbd 100644 --- a/src/jami/def.h +++ b/src/jami/def.h @@ -23,33 +23,33 @@ // Generic helper definitions for shared library support #if defined _WIN32 || defined __CYGWIN__ -#define DRING_IMPORT __declspec(dllimport) -#define DRING_EXPORT __declspec(dllexport) -#define DRING_HIDDEN +#define LIBJAMI_IMPORT __declspec(dllimport) +#define LIBJAMI_EXPORT __declspec(dllexport) +#define LIBJAMI_HIDDEN #else -#define DRING_IMPORT __attribute__((visibility("default"))) -#define DRING_EXPORT __attribute__((visibility("default"))) -#define DRING_HIDDEN __attribute__((visibility("hidden"))) +#define LIBJAMI_IMPORT __attribute__((visibility("default"))) +#define LIBJAMI_EXPORT __attribute__((visibility("default"))) +#define LIBJAMI_HIDDEN __attribute__((visibility("hidden"))) #endif -// Now we use the generic helper definitions above to define DRING_PUBLIC and DRING_LOCAL. -// DRING_PUBLIC is used for the public API symbols. It is either DLL imports or DLL exports (or does -// nothing for static build) DRING_LOCAL is used for non-api symbols. +// Now we use the generic helper definitions above to define LIBJAMI_PUBLIC and LIBJAMI_LOCAL. +// LIBJAMI_PUBLIC is used for the public API symbols. It is either DLL imports or DLL exports (or does +// nothing for static build) LIBJAMI_LOCAL is used for non-api symbols. #ifdef jami_EXPORTS // defined if Jami is compiled as a shared library -#ifdef DRING_BUILD // defined if we are building the Jami shared library (instead of using it) -#define DRING_PUBLIC DRING_EXPORT +#ifdef LIBJAMI_BUILD // defined if we are building the Jami shared library (instead of using it) +#define LIBJAMI_PUBLIC LIBJAMI_EXPORT #else -#define DRING_PUBLIC DRING_IMPORT -#endif // DRING_BUILD -#define DRING_LOCAL DRING_HIDDEN -#else // dring_EXPORTS is not defined: this means Jami is a static lib. -#define DRING_PUBLIC -#define DRING_LOCAL +#define LIBJAMI_PUBLIC LIBJAMI_IMPORT +#endif // LIBJAMI_BUILD +#define LIBJAMI_LOCAL LIBJAMI_HIDDEN +#else // jami_EXPORTS is not defined: this means Jami is a static lib. +#define LIBJAMI_PUBLIC +#define LIBJAMI_LOCAL #endif // jami_EXPORTS #ifdef DEBUG -#define DRING_TESTABLE DRING_EXPORT +#define LIBJAMI_TESTABLE LIBJAMI_EXPORT #else -#define DRING_TESTABLE +#define LIBJAMI_TESTABLE #endif diff --git a/src/jami/jami.h b/src/jami/jami.h index 09b6f9e4a..e3dd43b5b 100644 --- a/src/jami/jami.h +++ b/src/jami/jami.h @@ -18,8 +18,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_H -#define DRING_H +#ifndef LIBJAMI_H +#define LIBJAMI_H #include "def.h" @@ -32,25 +32,25 @@ #include "trace-tools.h" -namespace DRing { +namespace libjami { /* flags for initialization */ enum InitFlag { - DRING_FLAG_DEBUG = 1 << 0, - DRING_FLAG_CONSOLE_LOG = 1 << 1, - DRING_FLAG_AUTOANSWER = 1 << 2, - DRING_FLAG_IOS_EXTENSION = 1 << 4, + LIBJAMI_FLAG_DEBUG = 1 << 0, + LIBJAMI_FLAG_CONSOLE_LOG = 1 << 1, + LIBJAMI_FLAG_AUTOANSWER = 1 << 2, + LIBJAMI_FLAG_IOS_EXTENSION = 1 << 4, }; /** * Return the library version as string. */ -DRING_PUBLIC const char* version() noexcept; +LIBJAMI_PUBLIC const char* version() noexcept; /** * Return the target platform (OS) as a string. */ -DRING_PUBLIC const char* platform() noexcept; +LIBJAMI_PUBLIC const char* platform() noexcept; /** * Initialize globals, create underlaying daemon. @@ -58,27 +58,27 @@ DRING_PUBLIC const char* platform() noexcept; * @param flags Flags to customize this initialization * @returns true if initialization succeed else false. */ -DRING_PUBLIC bool init(enum InitFlag flags) noexcept; +LIBJAMI_PUBLIC bool init(enum InitFlag flags) noexcept; /** * Start asynchronously daemon created by init(). * @returns true if daemon started successfully */ -DRING_PUBLIC bool start(const std::string& config_file = {}) noexcept; +LIBJAMI_PUBLIC bool start(const std::string& config_file = {}) noexcept; /** * Stop and freeing any resource allocated by daemon */ -DRING_PUBLIC void fini() noexcept; +LIBJAMI_PUBLIC void fini() noexcept; -DRING_PUBLIC bool initialized() noexcept; +LIBJAMI_PUBLIC bool initialized() noexcept; /** * Control log handlers. * * @param whom Log handler to control */ -DRING_PUBLIC void logging(const std::string& whom, const std::string& action) noexcept; +LIBJAMI_PUBLIC void logging(const std::string& whom, const std::string& action) noexcept; /* External Callback Dynamic Utilities * @@ -101,7 +101,7 @@ DRING_PUBLIC void logging(const std::string& whom, const std::string& action) no * Used conjointly with std::shared_ptr to hide the concrete class. * See CallbackWrapper template for details. */ -class DRING_PUBLIC CallbackWrapperBase +class LIBJAMI_PUBLIC CallbackWrapperBase {}; /* Concrete class of CallbackWrapperBase. @@ -173,12 +173,12 @@ exportable_callback(std::function&& func, std::forward>(func), file, linum)); } -DRING_PUBLIC void registerSignalHandlers( +LIBJAMI_PUBLIC void registerSignalHandlers( const std::map>&); -DRING_PUBLIC void unregisterSignalHandlers(); +LIBJAMI_PUBLIC void unregisterSignalHandlers(); using MediaMap = std::map; -} // namespace DRing +} // namespace libjami -#endif /* DRING_H */ +#endif /* LIBJAMI_H */ diff --git a/src/jami/media_const.h b/src/jami/media_const.h index 785d05ae2..0b09f7162 100644 --- a/src/jami/media_const.h +++ b/src/jami/media_const.h @@ -17,12 +17,12 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_MEDIA_H -#define DRING_MEDIA_H +#ifndef LIBJAMI_MEDIA_H +#define LIBJAMI_MEDIA_H #include "def.h" -namespace DRing { +namespace libjami { namespace Media { @@ -74,6 +74,6 @@ constexpr static auto NEGOTIATION_FAIL = "NEGOTIATION_FAIL"; } // namespace Media -} // namespace DRing +} // namespace libjami #endif diff --git a/src/jami/plugin_manager_interface.h b/src/jami/plugin_manager_interface.h index 2d16610a3..a50b0966d 100644 --- a/src/jami/plugin_manager_interface.h +++ b/src/jami/plugin_manager_interface.h @@ -33,57 +33,57 @@ #import "TargetConditionals.h" #endif -namespace DRing { -DRING_PUBLIC bool loadPlugin(const std::string& path); -DRING_PUBLIC bool unloadPlugin(const std::string& path); -DRING_PUBLIC std::map getPluginDetails(const std::string& path); -DRING_PUBLIC std::vector> getPluginPreferences( +namespace libjami { +LIBJAMI_PUBLIC bool loadPlugin(const std::string& path); +LIBJAMI_PUBLIC bool unloadPlugin(const std::string& path); +LIBJAMI_PUBLIC std::map getPluginDetails(const std::string& path); +LIBJAMI_PUBLIC std::vector> getPluginPreferences( const std::string& path, const std::string& accountId); -DRING_PUBLIC bool setPluginPreference(const std::string& path, +LIBJAMI_PUBLIC bool setPluginPreference(const std::string& path, const std::string& accountId, const std::string& key, const std::string& value); -DRING_PUBLIC std::map getPluginPreferencesValues( +LIBJAMI_PUBLIC std::map getPluginPreferencesValues( const std::string& path, const std::string& accountId); -DRING_PUBLIC bool resetPluginPreferencesValues(const std::string& path, +LIBJAMI_PUBLIC bool resetPluginPreferencesValues(const std::string& path, const std::string& accountId); -DRING_PUBLIC std::vector getInstalledPlugins(); -DRING_PUBLIC std::vector getLoadedPlugins(); -DRING_PUBLIC int installPlugin(const std::string& jplPath, bool force); -DRING_PUBLIC int uninstallPlugin(const std::string& pluginRootPath); -DRING_PUBLIC std::vector getCallMediaHandlers(); -DRING_PUBLIC std::vector getChatHandlers(); -DRING_PUBLIC void toggleCallMediaHandler(const std::string& mediaHandlerId, +LIBJAMI_PUBLIC std::vector getInstalledPlugins(); +LIBJAMI_PUBLIC std::vector getLoadedPlugins(); +LIBJAMI_PUBLIC int installPlugin(const std::string& jplPath, bool force); +LIBJAMI_PUBLIC int uninstallPlugin(const std::string& pluginRootPath); +LIBJAMI_PUBLIC std::vector getCallMediaHandlers(); +LIBJAMI_PUBLIC std::vector getChatHandlers(); +LIBJAMI_PUBLIC void toggleCallMediaHandler(const std::string& mediaHandlerId, const std::string& callId, bool toggle); -DRING_PUBLIC void toggleChatHandler(const std::string& chatHandlerId, +LIBJAMI_PUBLIC void toggleChatHandler(const std::string& chatHandlerId, const std::string& accountId, const std::string& peerId, bool toggle); -DRING_PUBLIC std::map getCallMediaHandlerDetails( +LIBJAMI_PUBLIC std::map getCallMediaHandlerDetails( const std::string& mediaHandlerId); -DRING_PUBLIC std::vector getCallMediaHandlerStatus(const std::string& callId); -DRING_PUBLIC std::map getChatHandlerDetails( +LIBJAMI_PUBLIC std::vector getCallMediaHandlerStatus(const std::string& callId); +LIBJAMI_PUBLIC std::map getChatHandlerDetails( const std::string& chatHandlerId); -DRING_PUBLIC std::vector getChatHandlerStatus(const std::string& accountId, +LIBJAMI_PUBLIC std::vector getChatHandlerStatus(const std::string& accountId, const std::string& peerId); -DRING_PUBLIC bool getPluginsEnabled(); -DRING_PUBLIC void setPluginsEnabled(bool state); +LIBJAMI_PUBLIC bool getPluginsEnabled(); +LIBJAMI_PUBLIC void setPluginsEnabled(bool state); -DRING_PUBLIC void sendWebViewMessage(const std::string& pluginId, +LIBJAMI_PUBLIC void sendWebViewMessage(const std::string& pluginId, const std::string& webViewId, const std::string& messageId, const std::string& payload); -DRING_PUBLIC std::string sendWebViewAttach(const std::string& pluginId, +LIBJAMI_PUBLIC std::string sendWebViewAttach(const std::string& pluginId, const std::string& accountId, const std::string& webViewId, const std::string& action); -DRING_PUBLIC void sendWebViewDetach(const std::string& pluginId, const std::string& webViewId); +LIBJAMI_PUBLIC void sendWebViewDetach(const std::string& pluginId, const std::string& webViewId); namespace PluginSignal { -struct DRING_PUBLIC WebViewMessageReceived +struct LIBJAMI_PUBLIC WebViewMessageReceived { constexpr static const char* name = "WebViewMessageReceived"; using cb_type = void(const std::string& /*pluginId*/, @@ -93,4 +93,4 @@ struct DRING_PUBLIC WebViewMessageReceived }; } // namespace PluginSignal -} // namespace DRing +} // namespace libjami diff --git a/src/jami/presence_const.h b/src/jami/presence_const.h index 5e08ddc5d..cdee345a9 100644 --- a/src/jami/presence_const.h +++ b/src/jami/presence_const.h @@ -17,12 +17,12 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_PRESENCE_CONST_H -#define DRING_PRESENCE_CONST_H +#ifndef LIBJAMI_PRESENCE_CONST_H +#define LIBJAMI_PRESENCE_CONST_H #include "def.h" -namespace DRing { +namespace libjami { namespace Presence { @@ -34,6 +34,6 @@ constexpr static const char* OFFLINE_KEY = "Offline"; } // namespace Presence -} // namespace DRing +} // namespace libjami #endif diff --git a/src/jami/presencemanager_interface.h b/src/jami/presencemanager_interface.h index 610404141..fe5fb25f3 100644 --- a/src/jami/presencemanager_interface.h +++ b/src/jami/presencemanager_interface.h @@ -18,8 +18,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_PRESENCEMANAGERI_H -#define DRING_PRESENCEMANAGERI_H +#ifndef LIBJAMI_PRESENCEMANAGERI_H +#define LIBJAMI_PRESENCEMANAGERI_H #include "def.h" @@ -31,36 +31,36 @@ #include "jami.h" #include "presence_const.h" -namespace DRing { +namespace libjami { -[[deprecated("Replaced by registerSignalHandlers")]] DRING_PUBLIC void registerPresHandlers( +[[deprecated("Replaced by registerSignalHandlers")]] LIBJAMI_PUBLIC void registerPresHandlers( const std::map>&); /* Presence subscription/Notification. */ -DRING_PUBLIC void publish(const std::string& accountID, bool status, const std::string& note); -DRING_PUBLIC void answerServerRequest(const std::string& uri, bool flag); -DRING_PUBLIC void subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag); -DRING_PUBLIC std::vector> getSubscriptions( +LIBJAMI_PUBLIC void publish(const std::string& accountID, bool status, const std::string& note); +LIBJAMI_PUBLIC void answerServerRequest(const std::string& uri, bool flag); +LIBJAMI_PUBLIC void subscribeBuddy(const std::string& accountID, const std::string& uri, bool flag); +LIBJAMI_PUBLIC std::vector> getSubscriptions( const std::string& accountID); -DRING_PUBLIC void setSubscriptions(const std::string& accountID, +LIBJAMI_PUBLIC void setSubscriptions(const std::string& accountID, const std::vector& uris); // Presence signal type definitions -struct DRING_PUBLIC PresenceSignal +struct LIBJAMI_PUBLIC PresenceSignal { - struct DRING_PUBLIC NewServerSubscriptionRequest + struct LIBJAMI_PUBLIC NewServerSubscriptionRequest { constexpr static const char* name = "NewServerSubscriptionRequest"; using cb_type = void(const std::string& /*remote*/); }; - struct DRING_PUBLIC ServerError + struct LIBJAMI_PUBLIC ServerError { constexpr static const char* name = "ServerError"; using cb_type = void(const std::string& /*account_id*/, const std::string& /*error*/, const std::string& /*msg*/); }; - struct DRING_PUBLIC NewBuddyNotification + struct LIBJAMI_PUBLIC NewBuddyNotification { constexpr static const char* name = "NewBuddyNotification"; using cb_type = void(const std::string& /*account_id*/, @@ -68,7 +68,7 @@ struct DRING_PUBLIC PresenceSignal int /*status*/, const std::string& /*line_status*/); }; - struct DRING_PUBLIC NearbyPeerNotification + struct LIBJAMI_PUBLIC NearbyPeerNotification { constexpr static const char* name = "NearbyPeerNotification"; using cb_type = void(const std::string& /*account_id*/, @@ -76,7 +76,7 @@ struct DRING_PUBLIC PresenceSignal int /*state*/, const std::string& /*displayname*/); }; - struct DRING_PUBLIC SubscriptionStateChanged + struct LIBJAMI_PUBLIC SubscriptionStateChanged { constexpr static const char* name = "SubscriptionStateChanged"; using cb_type = void(const std::string& /*account_id*/, @@ -85,6 +85,6 @@ struct DRING_PUBLIC PresenceSignal }; }; -} // namespace DRing +} // namespace libjami #endif // PRESENCEMANAGERI_H diff --git a/src/jami/security_const.h b/src/jami/security_const.h index 7c8427c09..88860eaf2 100644 --- a/src/jami/security_const.h +++ b/src/jami/security_const.h @@ -17,12 +17,12 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef DRING_SECURITY_H -#define DRING_SECURITY_H +#ifndef LIBJAMI_SECURITY_H +#define LIBJAMI_SECURITY_H #include "def.h" -namespace DRing { +namespace libjami { namespace Certificate { @@ -121,6 +121,6 @@ constexpr static char TLS_PEER_CA_[] = "TLS_PEER_CA_"; constexpr static char TLS_CIPHER[] = "TLS_CIPHER"; } // namespace TlsTransport -} // namespace DRing +} // namespace libjami #endif diff --git a/src/jami/videomanager_interface.h b/src/jami/videomanager_interface.h index 3c001db5a..972bacd44 100644 --- a/src/jami/videomanager_interface.h +++ b/src/jami/videomanager_interface.h @@ -51,18 +51,18 @@ namespace jami { struct AudioFormat; } -namespace DRing { +namespace libjami { -[[deprecated("Replaced by registerSignalHandlers")]] DRING_PUBLIC void registerVideoHandlers( +[[deprecated("Replaced by registerSignalHandlers")]] LIBJAMI_PUBLIC void registerVideoHandlers( const std::map>&); -struct DRING_PUBLIC AVFrame_deleter { +struct LIBJAMI_PUBLIC AVFrame_deleter { void operator()(AVFrame* frame) const { av_frame_free(&frame); } }; typedef std::unique_ptr FrameBuffer; -class DRING_PUBLIC MediaFrame +class LIBJAMI_PUBLIC MediaFrame { public: // Construct an empty MediaFrame @@ -93,7 +93,7 @@ protected: std::unique_ptr packet_; }; -class DRING_PUBLIC AudioFrame : public MediaFrame +class LIBJAMI_PUBLIC AudioFrame : public MediaFrame { public: AudioFrame() @@ -112,7 +112,7 @@ private: void reserve(size_t nb_samples = 0); }; -class DRING_PUBLIC VideoFrame : public MediaFrame +class LIBJAMI_PUBLIC VideoFrame : public MediaFrame { public: // Construct an empty VideoFrame @@ -164,7 +164,7 @@ private: void setGeometry(int format, int width, int height) noexcept; }; -struct DRING_PUBLIC SinkTarget +struct LIBJAMI_PUBLIC SinkTarget { std::function pull; std::function push; @@ -173,55 +173,55 @@ struct DRING_PUBLIC SinkTarget using VideoCapabilities = std::map>>; -DRING_PUBLIC std::vector getDeviceList(); -DRING_PUBLIC VideoCapabilities getCapabilities(const std::string& deviceId); -DRING_PUBLIC std::map getSettings(const std::string& deviceId); -DRING_PUBLIC void applySettings(const std::string& deviceId, +LIBJAMI_PUBLIC std::vector getDeviceList(); +LIBJAMI_PUBLIC VideoCapabilities getCapabilities(const std::string& deviceId); +LIBJAMI_PUBLIC std::map getSettings(const std::string& deviceId); +LIBJAMI_PUBLIC void applySettings(const std::string& deviceId, const std::map& settings); -DRING_PUBLIC void setDefaultDevice(const std::string& deviceId); -DRING_PUBLIC void setDeviceOrientation(const std::string& deviceId, int angle); -DRING_PUBLIC std::map getDeviceParams(const std::string& deviceId); -DRING_PUBLIC std::string getDefaultDevice(); -DRING_PUBLIC void startAudioDevice(); -DRING_PUBLIC void stopAudioDevice(); +LIBJAMI_PUBLIC void setDefaultDevice(const std::string& deviceId); +LIBJAMI_PUBLIC void setDeviceOrientation(const std::string& deviceId, int angle); +LIBJAMI_PUBLIC std::map getDeviceParams(const std::string& deviceId); +LIBJAMI_PUBLIC std::string getDefaultDevice(); +LIBJAMI_PUBLIC void startAudioDevice(); +LIBJAMI_PUBLIC void stopAudioDevice(); -DRING_PUBLIC std::string openVideoInput(const std::string& path); -DRING_PUBLIC bool closeVideoInput(const std::string& id); +LIBJAMI_PUBLIC std::string openVideoInput(const std::string& path); +LIBJAMI_PUBLIC bool closeVideoInput(const std::string& id); -DRING_PUBLIC std::string createMediaPlayer(const std::string& path); -DRING_PUBLIC bool closeMediaPlayer(const std::string& id); -DRING_PUBLIC bool pausePlayer(const std::string& id, bool pause); -DRING_PUBLIC bool mutePlayerAudio(const std::string& id, bool mute); -DRING_PUBLIC bool playerSeekToTime(const std::string& id, int time); +LIBJAMI_PUBLIC std::string createMediaPlayer(const std::string& path); +LIBJAMI_PUBLIC bool closeMediaPlayer(const std::string& id); +LIBJAMI_PUBLIC bool pausePlayer(const std::string& id, bool pause); +LIBJAMI_PUBLIC bool mutePlayerAudio(const std::string& id, bool mute); +LIBJAMI_PUBLIC bool playerSeekToTime(const std::string& id, int time); int64_t getPlayerPosition(const std::string& id); -DRING_PUBLIC bool registerSinkTarget(const std::string& sinkId, SinkTarget target); +LIBJAMI_PUBLIC bool registerSinkTarget(const std::string& sinkId, SinkTarget target); #ifdef ENABLE_SHM -DRING_PUBLIC void startShmSink(const std::string& sinkId, bool value); +LIBJAMI_PUBLIC void startShmSink(const std::string& sinkId, bool value); #endif -DRING_PUBLIC std::map getRenderer(const std::string& callId); +LIBJAMI_PUBLIC std::map getRenderer(const std::string& callId); -DRING_PUBLIC std::string startLocalMediaRecorder(const std::string& videoInputId, +LIBJAMI_PUBLIC std::string startLocalMediaRecorder(const std::string& videoInputId, const std::string& filepath); -DRING_PUBLIC void stopLocalRecorder(const std::string& filepath); +LIBJAMI_PUBLIC void stopLocalRecorder(const std::string& filepath); #if defined(__ANDROID__) || defined(RING_UWP) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) -DRING_PUBLIC void addVideoDevice( +LIBJAMI_PUBLIC void addVideoDevice( const std::string& node, const std::vector>& devInfo = {}); -DRING_PUBLIC void removeVideoDevice(const std::string& node); -DRING_PUBLIC VideoFrame* getNewFrame(std::string_view id); -DRING_PUBLIC void publishFrame(std::string_view id); +LIBJAMI_PUBLIC void removeVideoDevice(const std::string& node); +LIBJAMI_PUBLIC VideoFrame* getNewFrame(std::string_view id); +LIBJAMI_PUBLIC void publishFrame(std::string_view id); #endif -DRING_PUBLIC bool getDecodingAccelerated(); -DRING_PUBLIC void setDecodingAccelerated(bool state); -DRING_PUBLIC bool getEncodingAccelerated(); -DRING_PUBLIC void setEncodingAccelerated(bool state); +LIBJAMI_PUBLIC bool getDecodingAccelerated(); +LIBJAMI_PUBLIC void setDecodingAccelerated(bool state); +LIBJAMI_PUBLIC bool getEncodingAccelerated(); +LIBJAMI_PUBLIC void setEncodingAccelerated(bool state); // player signal type definitions -struct DRING_PUBLIC MediaPlayerSignal +struct LIBJAMI_PUBLIC MediaPlayerSignal { - struct DRING_PUBLIC FileOpened + struct LIBJAMI_PUBLIC FileOpened { constexpr static const char* name = "FileOpened"; using cb_type = void(const std::string& /*playerId*/, @@ -230,14 +230,14 @@ struct DRING_PUBLIC MediaPlayerSignal }; // Video signal type definitions -struct DRING_PUBLIC VideoSignal +struct LIBJAMI_PUBLIC VideoSignal { - struct DRING_PUBLIC DeviceEvent + struct LIBJAMI_PUBLIC DeviceEvent { constexpr static const char* name = "DeviceEvent"; using cb_type = void(void); }; - struct DRING_PUBLIC DecodingStarted + struct LIBJAMI_PUBLIC DecodingStarted { constexpr static const char* name = "DecodingStarted"; using cb_type = void(const std::string& /*id*/, @@ -246,7 +246,7 @@ struct DRING_PUBLIC VideoSignal int /*h*/, bool /*is_mixer*/ id); }; - struct DRING_PUBLIC DecodingStopped + struct LIBJAMI_PUBLIC DecodingStopped { constexpr static const char* name = "DecodingStopped"; using cb_type = void(const std::string& /*id*/, @@ -254,7 +254,7 @@ struct DRING_PUBLIC VideoSignal bool /*is_mixer*/); }; #ifdef __ANDROID__ - struct DRING_PUBLIC SetParameters + struct LIBJAMI_PUBLIC SetParameters { constexpr static const char* name = "SetParameters"; using cb_type = void(const std::string& device, @@ -263,7 +263,7 @@ struct DRING_PUBLIC VideoSignal const int height, const int rate); }; - struct DRING_PUBLIC GetCameraInfo + struct LIBJAMI_PUBLIC GetCameraInfo { constexpr static const char* name = "GetCameraInfo"; using cb_type = void(const std::string& device, @@ -271,39 +271,39 @@ struct DRING_PUBLIC VideoSignal std::vector* sizes, std::vector* rates); }; - struct DRING_PUBLIC RequestKeyFrame + struct LIBJAMI_PUBLIC RequestKeyFrame { constexpr static const char* name = "RequestKeyFrame"; using cb_type = void(const std::string& /*device*/); }; - struct DRING_PUBLIC SetBitrate + struct LIBJAMI_PUBLIC SetBitrate { constexpr static const char* name = "SetBitrate"; using cb_type = void(const std::string& /*device*/, const int bitrate); }; #endif - struct DRING_PUBLIC StartCapture + struct LIBJAMI_PUBLIC StartCapture { constexpr static const char* name = "StartCapture"; using cb_type = void(const std::string& /*device*/); }; - struct DRING_PUBLIC StopCapture + struct LIBJAMI_PUBLIC StopCapture { constexpr static const char* name = "StopCapture"; using cb_type = void(const std::string& /*device*/); }; - struct DRING_PUBLIC DeviceAdded + struct LIBJAMI_PUBLIC DeviceAdded { constexpr static const char* name = "DeviceAdded"; using cb_type = void(const std::string& /*device*/); }; - struct DRING_PUBLIC ParametersChanged + struct LIBJAMI_PUBLIC ParametersChanged { constexpr static const char* name = "ParametersChanged"; using cb_type = void(const std::string& /*device*/); }; }; -} // namespace DRing +} // namespace libjami #endif // DENABLE_VIDEOMANAGERI_H diff --git a/src/jamidht/account_manager.cpp b/src/jamidht/account_manager.cpp index 6356a3429..17519a654 100644 --- a/src/jamidht/account_manager.cpp +++ b/src/jamidht/account_manager.cpp @@ -268,7 +268,7 @@ AccountManager::startSync(const OnNewDeviceCb& cb, const OnDeviceAnnouncedCb& dc auto conversationId = v.conversationId; // Check if there was an old active conversation. auto details = info_->contacts->getContactDetails(peer_account); - auto oldConvIt = details.find(DRing::Account::TrustRequest::CONVERSATIONID); + auto oldConvIt = details.find(libjami::Account::TrustRequest::CONVERSATIONID); if (oldConvIt != details.end() && oldConvIt->second != "") { if (conversationId == oldConvIt->second) return; @@ -561,7 +561,7 @@ AccountManager::acceptTrustRequest(const std::string& from, bool includeConversa if (info_->contacts->acceptTrustRequest(f)) { sendTrustRequestConfirm(f, includeConversation - ? req[DRing::Account::TrustRequest::CONVERSATIONID] + ? req[libjami::Account::TrustRequest::CONVERSATIONID] : ""); syncDevices(); return true; diff --git a/src/jamidht/accountarchive.cpp b/src/jamidht/accountarchive.cpp index b70f436df..0a1e01d7c 100644 --- a/src/jamidht/accountarchive.cpp +++ b/src/jamidht/accountarchive.cpp @@ -50,14 +50,14 @@ AccountArchive::deserialize(const std::vector& dat) const auto key = itr.key().asString(); if (key.empty()) continue; - if (key.compare(DRing::Account::ConfProperties::TLS::CA_LIST_FILE) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::TLS::CERTIFICATE_FILE) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::DHT_PROXY_LIST_URL) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::AUTOANSWER) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::PROXY_ENABLED) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::PROXY_SERVER) == 0) { - } else if (key.compare(DRing::Account::ConfProperties::PROXY_PUSH_TOKEN) == 0) { + if (key.compare(libjami::Account::ConfProperties::TLS::CA_LIST_FILE) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::TLS::PRIVATE_KEY_FILE) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::TLS::CERTIFICATE_FILE) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::DHT_PROXY_LIST_URL) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::AUTOANSWER) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::PROXY_ENABLED) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::PROXY_SERVER) == 0) { + } else if (key.compare(libjami::Account::ConfProperties::PROXY_PUSH_TOKEN) == 0) { } else if (key.compare(Conf::RING_CA_KEY) == 0) { ca_key = std::make_shared( base64::decode(itr->asString())); diff --git a/src/jamidht/archive_account_manager.cpp b/src/jamidht/archive_account_manager.cpp index 7d7260cb6..18ffbb8f4 100644 --- a/src/jamidht/archive_account_manager.cpp +++ b/src/jamidht/archive_account_manager.cpp @@ -625,7 +625,7 @@ ArchiveAccountManager::readArchive(const std::string& pwd) const void ArchiveAccountManager::updateArchive(AccountArchive& archive) const { - using namespace DRing::Account::ConfProperties; + using namespace libjami::Account::ConfProperties; // Keys not exported to archive static const auto filtered_keys = {Ringtone::PATH, diff --git a/src/jamidht/connectionmanager.cpp b/src/jamidht/connectionmanager.cpp index ed6ab2345..e3b123fb3 100644 --- a/src/jamidht/connectionmanager.cpp +++ b/src/jamidht/connectionmanager.cpp @@ -700,7 +700,7 @@ ConnectionManager::Impl::onDhtConnected(const dht::crypto::PublicKey& devicePk) if ((req.connType == "videoCall" || req.connType == "audioCall") && jami::Manager::instance().isIOSExtension) { bool hasVideo = req.connType == "videoCall"; - emitSignal( + emitSignal( shared->account.getAccountID(), peer_h.toString(), hasVideo); return; } diff --git a/src/jamidht/contact_list.cpp b/src/jamidht/contact_list.cpp index 755327a16..b9a21e17b 100644 --- a/src/jamidht/contact_list.cpp +++ b/src/jamidht/contact_list.cpp @@ -345,10 +345,10 @@ ContactList::getTrustRequests() const ret.reserve(trustRequests_.size()); for (const auto& r : trustRequests_) { ret.emplace_back( - Map {{DRing::Account::TrustRequest::FROM, r.first.toString()}, - {DRing::Account::TrustRequest::RECEIVED, std::to_string(r.second.received)}, - {DRing::Account::TrustRequest::CONVERSATIONID, r.second.conversationId}, - {DRing::Account::TrustRequest::PAYLOAD, + Map {{libjami::Account::TrustRequest::FROM, r.first.toString()}, + {libjami::Account::TrustRequest::RECEIVED, std::to_string(r.second.received)}, + {libjami::Account::TrustRequest::CONVERSATIONID, r.second.conversationId}, + {libjami::Account::TrustRequest::PAYLOAD, std::string(r.second.payload.begin(), r.second.payload.end())}}); } return ret; @@ -361,10 +361,10 @@ ContactList::getTrustRequest(const dht::InfoHash& from) const auto r = trustRequests_.find(from); if (r == trustRequests_.end()) return {}; - return Map {{DRing::Account::TrustRequest::FROM, r->first.toString()}, - {DRing::Account::TrustRequest::RECEIVED, std::to_string(r->second.received)}, - {DRing::Account::TrustRequest::CONVERSATIONID, r->second.conversationId}, - {DRing::Account::TrustRequest::PAYLOAD, + return Map {{libjami::Account::TrustRequest::FROM, r->first.toString()}, + {libjami::Account::TrustRequest::RECEIVED, std::to_string(r->second.received)}, + {libjami::Account::TrustRequest::CONVERSATIONID, r->second.conversationId}, + {libjami::Account::TrustRequest::PAYLOAD, std::string(r->second.payload.begin(), r->second.payload.end())}}; } diff --git a/src/jamidht/conversation.cpp b/src/jamidht/conversation.cpp index 0964c5679..f865acb4a 100644 --- a/src/jamidht/conversation.cpp +++ b/src/jamidht/conversation.cpp @@ -148,7 +148,7 @@ public: conversationId); if (!repository_) { if (auto shared = account.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), conversationId, EFETCH, "Couldn't clone repository"); } throw std::logic_error("Couldn't clone repository"); @@ -233,7 +233,7 @@ public: action = 4; if (action != -1) { announceMember = true; - emitSignal(accountId_, + emitSignal(accountId_, convId, uri, action); @@ -254,7 +254,7 @@ public: } #endif // announce message - emitSignal(accountId_, convId, c); + emitSignal(accountId_, convId, c); // check if we should update lastDisplayed // ignore merge commits as it's not generated by the user if (c.at("type") == "merge") @@ -737,12 +737,12 @@ Conversation::sendMessage(Json::Value&& value, if (onCommit) onCommit(commit); sthis->pimpl_->announce(commit); - emitSignal( + emitSignal( acc->getAccountID(), sthis->id(), acc->getUsername(), commit, - static_cast(DRing::Account::MessageStates::SENDING)); + static_cast(libjami::Account::MessageStates::SENDING)); if (cb) cb(!commit.empty(), commit); } @@ -956,7 +956,7 @@ Conversation::Impl::pull() if (find(changedFiles.begin(), changedFiles.end(), "profile.vcf") != changedFiles.end()) { if (auto account = account_.lock()) - emitSignal( + emitSignal( account->getAccountID(), repo->id(), repo->infos()); } } @@ -1064,7 +1064,7 @@ Conversation::updateInfos(const std::map& map, const O if (cb) cb(!commit.empty(), commit); if (auto account = sthis->pimpl_->account_.lock()) - emitSignal( + emitSignal( account->getAccountID(), repo->id(), repo->infos()); } }); @@ -1097,7 +1097,7 @@ Conversation::updatePreferences(const std::map& map) std::ofstream file(filePath, std::ios::trunc | std::ios::binary); msgpack::pack(file, prefs); - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, id(), std::move(prefs)); } @@ -1255,12 +1255,12 @@ Conversation::hasFetched(const std::string& deviceId, const std::string& commitI // Clear fetched commits and mark it as announced auto end = std::next(itCommit); for (auto it = sthis->pimpl_->sending_.begin(); it != end; ++it) { - emitSignal( + emitSignal( acc->getAccountID(), sthis->id(), acc->getUsername(), *it, - static_cast(DRing::Account::MessageStates::SENT)); + static_cast(libjami::Account::MessageStates::SENT)); } sthis->pimpl_->sending_.erase(sthis->pimpl_->sending_.begin(), end); sthis->pimpl_->saveSending(); @@ -1371,13 +1371,13 @@ Conversation::search(uint32_t req, return; auto commits = sthis->pimpl_->repository_->search(filter); if (commits.size() > 0) - emitSignal(req, + emitSignal(req, acc->getAccountID(), sthis->id(), std::move(commits)); // If we're the latest thread, inform client that the search is finished if ((*flag)-- == 1 /* decrement return the old value */) { - emitSignal( + emitSignal( req, acc->getAccountID(), std::string {}, diff --git a/src/jamidht/conversation_module.cpp b/src/jamidht/conversation_module.cpp index 6b3d15309..610014e21 100644 --- a/src/jamidht/conversation_module.cpp +++ b/src/jamidht/conversation_module.cpp @@ -151,12 +151,12 @@ public: saveConvInfos(); // Updates info for client - emitSignal( + emitSignal( accountId_, convId, username_, lastId, - static_cast(DRing::Account::MessageStates::DISPLAYED)); + static_cast(libjami::Account::MessageStates::DISPLAYED)); } std::string getOneToOneConversation(const std::string& uri) const noexcept; @@ -458,7 +458,7 @@ ConversationModule::Impl::fetchNewCommits(const std::string& peer, } if (syncCnt.fetch_sub(1) == 1) { if (auto account = account_.lock()) - emitSignal( + emitSignal( account->getAccountID().c_str()); } }, @@ -567,7 +567,7 @@ ConversationModule::Impl::handlePendingConversation(const std::string& conversat if (!commitId.empty()) sendMessageNotification(conversationId, commitId, false); // Inform user that the conversation is ready - emitSignal(accountId_, conversationId); + emitSignal(accountId_, conversationId); needsSyncingCb_({}); std::vector values; values.reserve(messages.size()); @@ -646,7 +646,7 @@ ConversationModule::Impl::getOneToOneConversation(const std::string& uri) const if (!acc) return {}; auto details = acc->getContactDetails(uri); - auto it = details.find(DRing::Account::TrustRequest::CONVERSATIONID); + auto it = details.find(libjami::Account::TrustRequest::CONVERSATIONID); if (it != details.end()) return it->second; return {}; @@ -736,7 +736,7 @@ ConversationModule::Impl::removeConversation(const std::string& conversationId) needsSyncingCb_({}); saveConvInfos(); lockCi.unlock(); - emitSignal(accountId_, conversationId); + emitSignal(accountId_, conversationId); if (isSyncing) return true; if (it->second->mode() != ConversationMode::ONE_TO_ONE) { @@ -1016,7 +1016,7 @@ ConversationModule::loadConversations() JAMI_WARNING("[Account {:s}] Conversation {:s} seems not present/synced.", pimpl_->accountId_, info.id); - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, info.id); itInfo = pimpl_->convInfos_.erase(itInfo); continue; @@ -1119,7 +1119,7 @@ ConversationModule::onTrustRequest(const std::string& uri, pimpl_->accountId_.c_str()); return; } - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, conversationId, uri, payload, @@ -1132,7 +1132,7 @@ ConversationModule::onTrustRequest(const std::string& uri, std::string_view(reinterpret_cast(payload.data()), payload.size()))); auto reqMap = req.toMap(); pimpl_->addConversationRequest(conversationId, std::move(req)); - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, conversationId, reqMap); } @@ -1160,7 +1160,7 @@ ConversationModule::onConversationRequest(const std::string& from, const Json::V // Note: no need to sync here because other connected devices should receive // the same conversation request. Will sync when the conversation will be added - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, convId, reqMap); } @@ -1214,7 +1214,7 @@ ConversationModule::declineConversationRequest(const std::string& conversationId it->second.declined = std::time(nullptr); pimpl_->saveConvRequests(); } - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, conversationId); pimpl_->needsSyncingCb_({}); } @@ -1251,7 +1251,7 @@ ConversationModule::startConversation(ConversationMode mode, const std::string& pimpl_->needsSyncingCb_({}); - emitSignal(pimpl_->accountId_, convId); + emitSignal(pimpl_->accountId_, convId); return convId; } @@ -1401,7 +1401,7 @@ ConversationModule::loadConversationMessages(const std::string& conversationId, options.nbOfCommits = n; conversation->second->loadMessages( [accountId = pimpl_->accountId_, conversationId, id](auto&& messages) { - emitSignal(id, + emitSignal(id, accountId, conversationId, messages); @@ -1428,7 +1428,7 @@ ConversationModule::loadConversationUntil(const std::string& conversationId, options.includeTo = true; conversation->second->loadMessages( [accountId = pimpl_->accountId_, conversationId, id](auto&& messages) { - emitSignal(id, + emitSignal(id, accountId, conversationId, messages); @@ -1506,7 +1506,7 @@ ConversationModule::syncConversations(const std::string& peer, const std::string pimpl_->cloneConversation(deviceId, peer, cid); if (pimpl_->syncCnt.load() == 0) { if (auto acc = pimpl_->account_.lock()) - emitSignal( + emitSignal( acc->getAccountID().c_str()); } } @@ -1537,7 +1537,7 @@ ConversationModule::onSyncData(const SyncMsg& msg, std::lock_guard lk(pimpl_->conversationsMtx_); auto itConv = pimpl_->conversations_.find(convId); if (itConv != pimpl_->conversations_.end() && !itConv->second->isRemoving()) { - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, convId); itConv->second->setRemovingFlag(); } @@ -1574,7 +1574,7 @@ ConversationModule::onSyncData(const SyncMsg& msg, pimpl_->accountId_.c_str(), convId.c_str(), deviceId.c_str()); - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, convId); continue; } @@ -1584,7 +1584,7 @@ ConversationModule::onSyncData(const SyncMsg& msg, convId.c_str(), deviceId.c_str()); - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, convId, req.toMap()); } @@ -1762,7 +1762,7 @@ ConversationModule::search(uint32_t req, const std::string& convId, const Filter for (const auto& [cid, conversation] : pimpl_->conversations_) { if (!conversation || (!convId.empty() && convId != cid)) { if ((*finishedFlag)-- == 1) { - emitSignal( + emitSignal( req, pimpl_->accountId_, std::string {}, @@ -1897,7 +1897,7 @@ ConversationModule::removeContact(const std::string& uri, bool banned) auto it = pimpl_->conversationsRequests_.begin(); while (it != pimpl_->conversationsRequests_.end()) { if (it->second.from == uri) { - emitSignal(pimpl_->accountId_, + emitSignal(pimpl_->accountId_, it->first); update = true; it = pimpl_->conversationsRequests_.erase(it); @@ -1917,7 +1917,7 @@ ConversationModule::removeContact(const std::string& uri, bool banned) auto updateClient = [&](const auto& convId) { if (pimpl_->updateConvReqCb_) pimpl_->updateConvReqCb_(convId, uri, false); - emitSignal(pimpl_->accountId_, convId); + emitSignal(pimpl_->accountId_, convId); }; { std::lock_guard lk(pimpl_->conversationsMtx_); diff --git a/src/jamidht/conversationrepository.cpp b/src/jamidht/conversationrepository.cpp index b0c3113f6..970376fc8 100644 --- a/src/jamidht/conversationrepository.cpp +++ b/src/jamidht/conversationrepository.cpp @@ -1748,7 +1748,7 @@ ConversationRepository::Impl::mode() const auto lastMsg = log(options); if (lastMsg.size() == 0) { if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EINVALIDMODE, "No initial commit"); @@ -1763,7 +1763,7 @@ ConversationRepository::Impl::mode() const auto reader = std::unique_ptr(rbuilder.newCharReader()); if (!reader->parse(commitMsg.data(), commitMsg.data() + commitMsg.size(), &root, &err)) { if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EINVALIDMODE, "No initial commit"); @@ -1772,7 +1772,7 @@ ConversationRepository::Impl::mode() const } if (!root.isMember("mode")) { if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EINVALIDMODE, "No mode detected"); @@ -1796,7 +1796,7 @@ ConversationRepository::Impl::mode() const break; default: if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EINVALIDMODE, "Incorrect mode detected"); @@ -2547,7 +2547,7 @@ ConversationRepository::Impl::validCommits( "version of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed initial commit"); } return false; @@ -2561,7 +2561,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed vote"); } return false; @@ -2577,7 +2577,7 @@ ConversationRepository::Impl::validCommits( &err)) { JAMI_ERR() << "Failed to parse " << err; if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed member commit"); } return false; @@ -2591,7 +2591,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, @@ -2606,7 +2606,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, @@ -2624,7 +2624,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, @@ -2644,7 +2644,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, @@ -2659,7 +2659,7 @@ ConversationRepository::Impl::validCommits( commit.id.c_str(), action.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed member commit"); } return false; @@ -2671,7 +2671,7 @@ ConversationRepository::Impl::validCommits( "of Jami, or that your contact is not doing unwanted stuff.", commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, @@ -2683,7 +2683,7 @@ ConversationRepository::Impl::validCommits( if (!checkEdit(userDevice, commit)) { JAMI_ERROR("Commit {:s} malformed", commit.id); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed edit commit"); } return false; @@ -2698,7 +2698,7 @@ ConversationRepository::Impl::validCommits( type.c_str(), commit.id.c_str()); if (auto shared = account_.lock()) { - emitSignal( + emitSignal( shared->getAccountID(), id_, EVALIDFETCH, "Malformed commit"); } return false; @@ -2715,7 +2715,7 @@ ConversationRepository::Impl::validCommits( validUserAtCommit.c_str(), commit.commit_msg.c_str()); if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EVALIDFETCH, "Malformed commit"); @@ -2730,7 +2730,7 @@ ConversationRepository::Impl::validCommits( "that your contact is not doing unwanted stuff.", validUserAtCommit.c_str()); if (auto shared = account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), id_, EVALIDFETCH, "Malformed commit"); @@ -2916,7 +2916,7 @@ ConversationRepository::fetch(const std::string& remoteDeviceId) err->message); if (auto shared = pimpl_->account_.lock()) { - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), pimpl_->id_, EFETCH, err->message); @@ -3251,12 +3251,12 @@ ConversationRepository::leave() if (!account || !repo) return {}; auto details = account->getAccountDetails(); - auto deviceId = details[DRing::Account::ConfProperties::DEVICE_ID]; - auto uri = details[DRing::Account::ConfProperties::USERNAME]; - auto name = details[DRing::Account::ConfProperties::DISPLAYNAME]; + auto deviceId = details[libjami::Account::ConfProperties::DEVICE_ID]; + auto uri = details[libjami::Account::ConfProperties::USERNAME]; + auto name = details[libjami::Account::ConfProperties::DISPLAYNAME]; if (name.empty()) name = account - ->getVolatileAccountDetails()[DRing::Account::VolatileProperties::REGISTERED_NAME]; + ->getVolatileAccountDetails()[libjami::Account::VolatileProperties::REGISTERED_NAME]; if (name.empty()) name = deviceId; @@ -3691,7 +3691,7 @@ ConversationRepository::updateInfos(const std::map& pr } if (!valid) { JAMI_ERR("Not enough authorization for updating infos"); - emitSignal( + emitSignal( account->getAccountID(), pimpl_->id_, EUNAUTHORIZED, diff --git a/src/jamidht/conversationrepository.h b/src/jamidht/conversationrepository.h index eb205acc4..cfa2893fd 100644 --- a/src/jamidht/conversationrepository.h +++ b/src/jamidht/conversationrepository.h @@ -126,7 +126,7 @@ struct ConversationMember /** * This class gives access to the git repository that represents the conversation */ -class DRING_TESTABLE ConversationRepository +class LIBJAMI_TESTABLE ConversationRepository { public: /** @@ -136,7 +136,7 @@ public: * @param otherMember The other uri * @return the conversation repository object */ - static DRING_TESTABLE std::unique_ptr createConversation( + static LIBJAMI_TESTABLE std::unique_ptr createConversation( const std::weak_ptr& account, ConversationMode mode = ConversationMode::INVITES_ONLY, const std::string& otherMember = ""); @@ -149,7 +149,7 @@ public: * @param conversationId Conversation to clone * @param socket Socket used to clone */ - static DRING_TESTABLE std::unique_ptr cloneConversation( + static LIBJAMI_TESTABLE std::unique_ptr cloneConversation( const std::weak_ptr& account, const std::string& deviceId, const std::string& conversationId); diff --git a/src/jamidht/gitserver.h b/src/jamidht/gitserver.h index 56047d340..f4dacd4bb 100644 --- a/src/jamidht/gitserver.h +++ b/src/jamidht/gitserver.h @@ -33,7 +33,7 @@ using onFetchedCb = std::function; /** * This class offers to a ChannelSocket the possibility to interact with a Git repository */ -class DRING_TESTABLE GitServer +class LIBJAMI_TESTABLE GitServer { public: /** diff --git a/src/jamidht/jamiaccount.cpp b/src/jamidht/jamiaccount.cpp index 8b65f5059..f960df051 100644 --- a/src/jamidht/jamiaccount.cpp +++ b/src/jamidht/jamiaccount.cpp @@ -171,7 +171,7 @@ mapStateNumberToString(const State migrationState) void setState(const std::string& accountID, const State migrationState) { - emitSignal(accountID, + emitSignal(accountID, mapStateNumberToString(migrationState)); } @@ -379,7 +379,7 @@ JamiAccount::flush() std::shared_ptr JamiAccount::newIncomingCall(const std::string& from, - const std::vector& mediaList, + const std::vector& mediaList, const std::shared_ptr& sipTransp) { JAMI_DEBUG("New incoming call from {:s} with {:d} media", from, mediaList.size()); @@ -412,7 +412,7 @@ JamiAccount::newIncomingCall(const std::string& from, } std::shared_ptr -JamiAccount::newOutgoingCall(std::string_view toUrl, const std::vector& mediaList) +JamiAccount::newOutgoingCall(std::string_view toUrl, const std::vector& mediaList) { auto suffix = stripPrefix(toUrl); JAMI_DBG() << *this << "Calling peer " << suffix; @@ -840,35 +840,35 @@ JamiAccount::serialize(YAML::Emitter& out) const out << YAML::Key << Conf::DHT_ALLOW_PEERS_FROM_HISTORY << YAML::Value << allowPeersFromHistory_; out << YAML::Key << Conf::DHT_ALLOW_PEERS_FROM_CONTACT << YAML::Value << allowPeersFromContact_; out << YAML::Key << Conf::DHT_ALLOW_PEERS_FROM_TRUSTED << YAML::Value << allowPeersFromTrusted_; - out << YAML::Key << DRing::Account::ConfProperties::DHT_PEER_DISCOVERY << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::DHT_PEER_DISCOVERY << YAML::Value << dhtPeerDiscovery_; - out << YAML::Key << DRing::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY << YAML::Value << accountPeerDiscovery_; - out << YAML::Key << DRing::Account::ConfProperties::ACCOUNT_PUBLISH << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::ACCOUNT_PUBLISH << YAML::Value << accountPublish_; out << YAML::Key << Conf::PROXY_ENABLED_KEY << YAML::Value << proxyEnabled_; out << YAML::Key << Conf::PROXY_SERVER_KEY << YAML::Value << proxyServer_; - out << YAML::Key << DRing::Account::ConfProperties::DHT_PROXY_LIST_URL << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::DHT_PROXY_LIST_URL << YAML::Value << proxyListUrl_; #if HAVE_RINGNS - out << YAML::Key << DRing::Account::ConfProperties::RingNS::URI << YAML::Value << nameServer_; + out << YAML::Key << libjami::Account::ConfProperties::RingNS::URI << YAML::Value << nameServer_; if (not registeredName_.empty()) - out << YAML::Key << DRing::Account::VolatileProperties::REGISTERED_NAME << YAML::Value + out << YAML::Key << libjami::Account::VolatileProperties::REGISTERED_NAME << YAML::Value << registeredName_; #endif - out << YAML::Key << DRing::Account::ConfProperties::ARCHIVE_PATH << YAML::Value << archivePath_; - out << YAML::Key << DRing::Account::ConfProperties::ARCHIVE_HAS_PASSWORD << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::ARCHIVE_PATH << YAML::Value << archivePath_; + out << YAML::Key << libjami::Account::ConfProperties::ARCHIVE_HAS_PASSWORD << YAML::Value << archiveHasPassword_; out << YAML::Key << Conf::RING_ACCOUNT_RECEIPT << YAML::Value << receipt_; if (receiptSignature_.size() > 0) out << YAML::Key << Conf::RING_ACCOUNT_RECEIPT_SIG << YAML::Value << YAML::Binary(receiptSignature_.data(), receiptSignature_.size()); - out << YAML::Key << DRing::Account::ConfProperties::DEVICE_NAME << YAML::Value << deviceName_; - out << YAML::Key << DRing::Account::ConfProperties::MANAGER_URI << YAML::Value << managerUri_; - out << YAML::Key << DRing::Account::ConfProperties::MANAGER_USERNAME << YAML::Value + out << YAML::Key << libjami::Account::ConfProperties::DEVICE_NAME << YAML::Value << deviceName_; + out << YAML::Key << libjami::Account::ConfProperties::MANAGER_URI << YAML::Value << managerUri_; + out << YAML::Key << libjami::Account::ConfProperties::MANAGER_USERNAME << YAML::Value << managerUsername_; // tls submap @@ -904,18 +904,18 @@ JamiAccount::unserialize(const YAML::Node& node) parseValue(node, Conf::PROXY_ENABLED_KEY, proxyEnabled_); parseValue(node, Conf::PROXY_SERVER_KEY, proxyServer_); try { - parseValue(node, DRing::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); + parseValue(node, libjami::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); } catch (const std::exception& e) { proxyListUrl_ = DHT_DEFAULT_PROXY_LIST_URL; } - parseValueOptional(node, DRing::Account::ConfProperties::DEVICE_NAME, deviceName_); - parseValueOptional(node, DRing::Account::ConfProperties::MANAGER_URI, managerUri_); - parseValueOptional(node, DRing::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); + parseValueOptional(node, libjami::Account::ConfProperties::DEVICE_NAME, deviceName_); + parseValueOptional(node, libjami::Account::ConfProperties::MANAGER_URI, managerUri_); + parseValueOptional(node, libjami::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); try { - parsePath(node, DRing::Account::ConfProperties::ARCHIVE_PATH, archivePath_, idPath_); - parseValue(node, DRing::Account::ConfProperties::ARCHIVE_HAS_PASSWORD, archiveHasPassword_); + parsePath(node, libjami::Account::ConfProperties::ARCHIVE_PATH, archivePath_, idPath_); + parseValue(node, libjami::Account::ConfProperties::ARCHIVE_HAS_PASSWORD, archiveHasPassword_); } catch (const std::exception& e) { JAMI_WARN("can't read archive path: %s", e.what()); archiveHasPassword_ = true; @@ -938,17 +938,17 @@ JamiAccount::unserialize(const YAML::Node& node) if (not dhtDefaultPort_) dhtDefaultPort_ = getRandomEvenPort(DHT_PORT_RANGE); - parseValueOptional(node, DRing::Account::ConfProperties::DHT_PEER_DISCOVERY, dhtPeerDiscovery_); + parseValueOptional(node, libjami::Account::ConfProperties::DHT_PEER_DISCOVERY, dhtPeerDiscovery_); parseValueOptional(node, - DRing::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, + libjami::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, accountPeerDiscovery_); - parseValueOptional(node, DRing::Account::ConfProperties::ACCOUNT_PUBLISH, accountPublish_); + parseValueOptional(node, libjami::Account::ConfProperties::ACCOUNT_PUBLISH, accountPublish_); #if HAVE_RINGNS - parseValueOptional(node, DRing::Account::ConfProperties::RingNS::URI, nameServer_); + parseValueOptional(node, libjami::Account::ConfProperties::RingNS::URI, nameServer_); if (registeredName_.empty()) { parseValueOptional(node, - DRing::Account::VolatileProperties::REGISTERED_NAME, + libjami::Account::VolatileProperties::REGISTERED_NAME, registeredName_); } #endif @@ -973,13 +973,13 @@ JamiAccount::changeArchivePassword(const std::string& password_old, const std::s ex.what()); if (password_old.empty()) { archiveHasPassword_ = true; - emitSignal(getAccountID(), + emitSignal(getAccountID(), getAccountDetails()); } return false; } if (password_old != password_new) - emitSignal(getAccountID(), + emitSignal(getAccountID(), getAccountDetails()); return true; } @@ -994,20 +994,20 @@ void JamiAccount::addDevice(const std::string& password) { if (not accountManager_) { - emitSignal(getAccountID(), 2, ""); + emitSignal(getAccountID(), 2, ""); return; } accountManager_ ->addDevice(password, [this](AccountManager::AddDeviceResult result, std::string pin) { switch (result) { case AccountManager::AddDeviceResult::SUCCESS_SHOW_PIN: - emitSignal(getAccountID(), 0, pin); + emitSignal(getAccountID(), 0, pin); break; case AccountManager::AddDeviceResult::ERROR_CREDENTIALS: - emitSignal(getAccountID(), 1, ""); + emitSignal(getAccountID(), 1, ""); break; case AccountManager::AddDeviceResult::ERROR_NETWORK: - emitSignal(getAccountID(), 2, ""); + emitSignal(getAccountID(), 2, ""); break; } }); @@ -1081,7 +1081,7 @@ JamiAccount::revokeDevice(const std::string& password, const std::string& device return false; return accountManager_ ->revokeDevice(password, device, [this, device](AccountManager::RevokeDeviceResult result) { - emitSignal(getAccountID(), + emitSignal(getAccountID(), device, static_cast(result)); }); @@ -1116,7 +1116,7 @@ JamiAccount::loadAccount(const std::string& archive_password, if (!id_.first) return; runOnMainThread([id = getAccountID(), uri, confirmed] { - emitSignal(id, uri, confirmed); + emitSignal(id, uri, confirmed); }); }, [this](const std::string& uri, bool banned) { @@ -1133,7 +1133,7 @@ JamiAccount::loadAccount(const std::string& archive_password, shared->connectionManager_->closeConnectionsWith(uri); } // Update client. - emitSignal(shared->getAccountID(), + emitSignal(shared->getAccountID(), uri, banned); } @@ -1148,7 +1148,7 @@ JamiAccount::loadAccount(const std::string& archive_password, clearProfileCache(uri); if (conversationId.empty()) { // Old path - emitSignal(getAccountID(), + emitSignal(getAccountID(), conversationId, uri, payload, @@ -1171,7 +1171,7 @@ JamiAccount::loadAccount(const std::string& archive_password, ids.emplace(std::move(id), std::move(label)); } runOnMainThread([id = getAccountID(), devices = std::move(ids)] { - emitSignal(id, devices); + emitSignal(id, devices); }); }, [this](const std::string& conversationId) { @@ -1308,11 +1308,11 @@ JamiAccount::loadAccount(const std::string& archive_password, registeredName_ = managerUsername_; deviceName_ = accountManager_->getAccountDeviceName(); - auto nameServerIt = config.find(DRing::Account::ConfProperties::RingNS::URI); + auto nameServerIt = config.find(libjami::Account::ConfProperties::RingNS::URI); if (nameServerIt != config.end() && !nameServerIt->second.empty()) { nameServer_ = nameServerIt->second; } - auto displayNameIt = config.find(DRing::Account::ConfProperties::DISPLAYNAME); + auto displayNameIt = config.find(libjami::Account::ConfProperties::DISPLAYNAME); if (displayNameIt != config.end() && !displayNameIt->second.empty()) { displayName_ = displayNameIt->second; } @@ -1330,7 +1330,7 @@ JamiAccount::loadAccount(const std::string& archive_password, setAccountDetails(details); if (not info.photo.empty() or not displayName_.empty()) - emitSignal(getAccountID(), + emitSignal(getAccountID(), displayName_, info.photo); setRegistrationState(RegistrationState::UNREGISTERED); @@ -1385,43 +1385,43 @@ JamiAccount::setAccountDetails(const std::map& details if (hostname_.empty()) hostname_ = DHT_DEFAULT_BOOTSTRAP; - parseString(details, DRing::Account::ConfProperties::BOOTSTRAP_LIST_URL, bootstrapListUrl_); + parseString(details, libjami::Account::ConfProperties::BOOTSTRAP_LIST_URL, bootstrapListUrl_); parseInt(details, Conf::CONFIG_DHT_PORT, dhtDefaultPort_); parseBool(details, Conf::CONFIG_DHT_PUBLIC_IN_CALLS, dhtPublicInCalls_); - parseBool(details, DRing::Account::ConfProperties::DHT_PEER_DISCOVERY, dhtPeerDiscovery_); + parseBool(details, libjami::Account::ConfProperties::DHT_PEER_DISCOVERY, dhtPeerDiscovery_); parseBool(details, - DRing::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, + libjami::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, accountPeerDiscovery_); - parseBool(details, DRing::Account::ConfProperties::ACCOUNT_PUBLISH, accountPublish_); + parseBool(details, libjami::Account::ConfProperties::ACCOUNT_PUBLISH, accountPublish_); parseBool(details, - DRing::Account::ConfProperties::ALLOW_CERT_FROM_HISTORY, + libjami::Account::ConfProperties::ALLOW_CERT_FROM_HISTORY, allowPeersFromHistory_); parseBool(details, - DRing::Account::ConfProperties::ALLOW_CERT_FROM_CONTACT, + libjami::Account::ConfProperties::ALLOW_CERT_FROM_CONTACT, allowPeersFromContact_); parseBool(details, - DRing::Account::ConfProperties::ALLOW_CERT_FROM_TRUSTED, + libjami::Account::ConfProperties::ALLOW_CERT_FROM_TRUSTED, allowPeersFromTrusted_); if (not dhtDefaultPort_) dhtDefaultPort_ = getRandomEvenPort(DHT_PORT_RANGE); - parseString(details, DRing::Account::ConfProperties::MANAGER_URI, managerUri_); - parseString(details, DRing::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); - parseString(details, DRing::Account::ConfProperties::USERNAME, username_); + parseString(details, libjami::Account::ConfProperties::MANAGER_URI, managerUri_); + parseString(details, libjami::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); + parseString(details, libjami::Account::ConfProperties::USERNAME, username_); std::string archive_password; std::string archive_pin; std::string archive_path; - parseString(details, DRing::Account::ConfProperties::ARCHIVE_PASSWORD, archive_password); - parseString(details, DRing::Account::ConfProperties::ARCHIVE_PIN, archive_pin); + parseString(details, libjami::Account::ConfProperties::ARCHIVE_PASSWORD, archive_password); + parseString(details, libjami::Account::ConfProperties::ARCHIVE_PIN, archive_pin); std::transform(archive_pin.begin(), archive_pin.end(), archive_pin.begin(), ::toupper); - parsePath(details, DRing::Account::ConfProperties::ARCHIVE_PATH, archive_path, idPath_); - parseString(details, DRing::Account::ConfProperties::DEVICE_NAME, deviceName_); + parsePath(details, libjami::Account::ConfProperties::ARCHIVE_PATH, archive_path, idPath_); + parseString(details, libjami::Account::ConfProperties::DEVICE_NAME, deviceName_); auto oldProxyServer = proxyServer_, oldProxyServerList = proxyListUrl_; - parseString(details, DRing::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); - parseBool(details, DRing::Account::ConfProperties::PROXY_ENABLED, proxyEnabled_); - parseString(details, DRing::Account::ConfProperties::PROXY_SERVER, proxyServer_); + parseString(details, libjami::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); + parseBool(details, libjami::Account::ConfProperties::PROXY_ENABLED, proxyEnabled_); + parseString(details, libjami::Account::ConfProperties::PROXY_SERVER, proxyServer_); // Migrate from old versions if (proxyServer_.empty() || ((proxyServer_ == "dhtproxy.jami.net" || proxyServer_ == "dhtproxy.ring.cx") @@ -1440,7 +1440,7 @@ JamiAccount::setAccountDetails(const std::map& details } #if HAVE_RINGNS - parseString(details, DRing::Account::ConfProperties::RingNS::URI, nameServer_); + parseString(details, libjami::Account::ConfProperties::RingNS::URI, nameServer_); #endif // update device name if necessary @@ -1457,22 +1457,22 @@ JamiAccount::getAccountDetails() const std::map a = SIPAccountBase::getAccountDetails(); a.emplace(Conf::CONFIG_DHT_PORT, std::to_string(dhtDefaultPort_)); a.emplace(Conf::CONFIG_DHT_PUBLIC_IN_CALLS, dhtPublicInCalls_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::DHT_PEER_DISCOVERY, + a.emplace(libjami::Account::ConfProperties::DHT_PEER_DISCOVERY, dhtPeerDiscovery_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, + a.emplace(libjami::Account::ConfProperties::ACCOUNT_PEER_DISCOVERY, accountPeerDiscovery_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::ACCOUNT_PUBLISH, + a.emplace(libjami::Account::ConfProperties::ACCOUNT_PUBLISH, accountPublish_ ? TRUE_STR : FALSE_STR); if (accountManager_) { if (auto info = accountManager_->getInfo()) { - a.emplace(DRing::Account::ConfProperties::DEVICE_ID, info->deviceId); - a.emplace(DRing::Account::ConfProperties::RingNS::ACCOUNT, info->ethAccount); + a.emplace(libjami::Account::ConfProperties::DEVICE_ID, info->deviceId); + a.emplace(libjami::Account::ConfProperties::RingNS::ACCOUNT, info->ethAccount); } } - a.emplace(DRing::Account::ConfProperties::DEVICE_NAME, deviceName_); - a.emplace(DRing::Account::ConfProperties::Presence::SUPPORT_SUBSCRIBE, TRUE_STR); + a.emplace(libjami::Account::ConfProperties::DEVICE_NAME, deviceName_); + a.emplace(libjami::Account::ConfProperties::Presence::SUPPORT_SUBSCRIBE, TRUE_STR); if (not archivePath_.empty() or not managerUri_.empty()) - a.emplace(DRing::Account::ConfProperties::ARCHIVE_HAS_PASSWORD, + a.emplace(libjami::Account::ConfProperties::ARCHIVE_HAS_PASSWORD, archiveHasPassword_ ? TRUE_STR : FALSE_STR); /* these settings cannot be changed (read only), but clients should still be @@ -1494,21 +1494,21 @@ JamiAccount::getAccountDetails() const a.emplace(Conf::CONFIG_TLS_VERIFY_CLIENT, TRUE_STR); a.emplace(Conf::CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE, TRUE_STR); a.emplace(Conf::CONFIG_TLS_DISABLE_SECURE_DLG_CHECK, TRUE_STR); - a.emplace(DRing::Account::ConfProperties::ALLOW_CERT_FROM_HISTORY, + a.emplace(libjami::Account::ConfProperties::ALLOW_CERT_FROM_HISTORY, allowPeersFromHistory_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::ALLOW_CERT_FROM_CONTACT, + a.emplace(libjami::Account::ConfProperties::ALLOW_CERT_FROM_CONTACT, allowPeersFromContact_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::ALLOW_CERT_FROM_TRUSTED, + a.emplace(libjami::Account::ConfProperties::ALLOW_CERT_FROM_TRUSTED, allowPeersFromTrusted_ ? TRUE_STR : FALSE_STR); /* GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT is defined as -1 */ a.emplace(Conf::CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC, "-1"); - a.emplace(DRing::Account::ConfProperties::PROXY_ENABLED, proxyEnabled_ ? TRUE_STR : FALSE_STR); - a.emplace(DRing::Account::ConfProperties::PROXY_SERVER, proxyServer_); - a.emplace(DRing::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); - a.emplace(DRing::Account::ConfProperties::MANAGER_URI, managerUri_); - a.emplace(DRing::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); + a.emplace(libjami::Account::ConfProperties::PROXY_ENABLED, proxyEnabled_ ? TRUE_STR : FALSE_STR); + a.emplace(libjami::Account::ConfProperties::PROXY_SERVER, proxyServer_); + a.emplace(libjami::Account::ConfProperties::DHT_PROXY_LIST_URL, proxyListUrl_); + a.emplace(libjami::Account::ConfProperties::MANAGER_URI, managerUri_); + a.emplace(libjami::Account::ConfProperties::MANAGER_USERNAME, managerUsername_); #if HAVE_RINGNS - a.emplace(DRing::Account::ConfProperties::RingNS::URI, nameServer_); + a.emplace(libjami::Account::ConfProperties::RingNS::URI, nameServer_); #endif return a; @@ -1518,13 +1518,13 @@ std::map JamiAccount::getVolatileAccountDetails() const { auto a = SIPAccountBase::getVolatileAccountDetails(); - a.emplace(DRing::Account::VolatileProperties::InstantMessaging::OFF_CALL, TRUE_STR); + a.emplace(libjami::Account::VolatileProperties::InstantMessaging::OFF_CALL, TRUE_STR); #if HAVE_RINGNS if (not registeredName_.empty()) - a.emplace(DRing::Account::VolatileProperties::REGISTERED_NAME, registeredName_); + a.emplace(libjami::Account::VolatileProperties::REGISTERED_NAME, registeredName_); #endif - a.emplace(DRing::Account::ConfProperties::PROXY_SERVER, proxyServerCached_); - a.emplace(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED, + a.emplace(libjami::Account::ConfProperties::PROXY_SERVER, proxyServerCached_); + a.emplace(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED, deviceAnnounced_ ? TRUE_STR : FALSE_STR); return a; @@ -1540,7 +1540,7 @@ JamiAccount::lookupName(const std::string& name) nameServer_, [acc = getAccountID(), name](const std::string& result, NameDirectory::Response response) { - emitSignal( + emitSignal( acc, (int) response, result, name); }); } @@ -1553,7 +1553,7 @@ JamiAccount::lookupAddress(const std::string& addr) if (accountManager_) accountManager_->lookupAddress( addr, [acc, addr](const std::string& result, NameDirectory::Response response) { - emitSignal(acc, + emitSignal(acc, (int) response, addr, result); @@ -1584,11 +1584,11 @@ JamiAccount::registerName(const std::string& password, const std::string& name) if (auto this_ = w.lock()) { this_->registeredName_ = name; this_->saveConfig(); - emitSignal( + emitSignal( this_->accountID_, this_->getVolatileAccountDetails()); } } - emitSignal(acc, res, name); + emitSignal(acc, res, name); }); } #endif @@ -1601,7 +1601,7 @@ JamiAccount::searchUser(const std::string& query) query, [acc = getAccountID(), query](const jami::NameDirectory::SearchResult& result, jami::NameDirectory::Response response) { - jami::emitSignal(acc, + jami::emitSignal(acc, (int) response, query, result); @@ -1873,7 +1873,7 @@ JamiAccount::onTrackedBuddyOnline(const dht::InfoHash& contactId) { std::string id(contactId.toString()); JAMI_DBG("Buddy %s online", id.c_str()); - emitSignal(getAccountID(), id, 1, ""); + emitSignal(getAccountID(), id, 1, ""); auto details = getContactDetails(id); auto it = details.find("confirmed"); @@ -1908,7 +1908,7 @@ void JamiAccount::onTrackedBuddyOffline(const dht::InfoHash& contactId) { JAMI_DBG("Buddy %s offline", contactId.toString().c_str()); - emitSignal(getAccountID(), + emitSignal(getAccountID(), contactId.toString(), 0, ""); @@ -1946,13 +1946,13 @@ JamiAccount::doRegister_() if (response == NameDirectory::Response::found) { if (this_->registeredName_ != result) { this_->registeredName_ = result; - emitSignal( + emitSignal( this_->accountID_, this_->getVolatileAccountDetails()); } } else if (response == NameDirectory::Response::notFound) { if (not this_->registeredName_.empty()) { this_->registeredName_.clear(); - emitSignal( + emitSignal( this_->accountID_, this_->getVolatileAccountDetails()); } } @@ -2021,7 +2021,7 @@ JamiAccount::doRegister_() auto now = std::chrono::duration_cast( std::chrono::steady_clock::now().time_since_epoch()) .count(); - jami::emitSignal(std::to_string(now) + " " + jami::emitSignal(std::to_string(now) + " " + std::string(tmp)); }; context.logger = std::make_shared(log_all, log_all, silent); @@ -2099,7 +2099,7 @@ JamiAccount::doRegister_() }, [this] { deviceAnnounced_ = true; - emitSignal( + emitSignal( accountID_, getVolatileAccountDetails()); }); }; @@ -2191,12 +2191,12 @@ JamiAccount::doRegister_() InternalCompletionCb cb; if (isVCard) cb = [peerId, accountId = getAccountID()](const std::string& path) { - emitSignal(accountId, + emitSignal(accountId, peerId, path); }; - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; info.accountId = getAccountID(); info.peer = peerId; try { @@ -2558,7 +2558,7 @@ JamiAccount::setCertificateStatus(const std::string& cert_id, bool done = accountManager_ ? accountManager_->setCertificateStatus(cert_id, status) : false; if (done) { findCertificate(cert_id); - emitSignal(getAccountID(), + emitSignal(getAccountID(), cert_id, tls::TrustStore::statusToStr( status)); @@ -2952,7 +2952,7 @@ JamiAccount::setMessageDisplayed(const std::string& conversationUri, std::string conversationId = {}; if (uri.scheme() == Uri::Scheme::SWARM) conversationId = uri.authority(); - auto sendMessage = status == (int) DRing::Account::MessageStates::DISPLAYED + auto sendMessage = status == (int) libjami::Account::MessageStates::DISPLAYED && isReadReceiptEnabled(); if (!conversationId.empty()) sendMessage &= convModule()->onMessageDisplayed(getUsername(), conversationId, messageId); @@ -3017,7 +3017,7 @@ JamiAccount::updateConvForContact(const std::string& uri, if (auto info = accountManager_->getInfo()) { auto urih = dht::InfoHash(uri); auto details = getContactDetails(uri); - auto itDetails = details.find(DRing::Account::TrustRequest::CONVERSATIONID); + auto itDetails = details.find(libjami::Account::TrustRequest::CONVERSATIONID); if (itDetails != details.end() && itDetails->second != oldConv) { JAMI_DBG("Old conversation is not found in details %s", oldConv.c_str()); return false; @@ -3025,8 +3025,8 @@ JamiAccount::updateConvForContact(const std::string& uri, info->contacts->updateConversation(urih, newConv); // Also decline trust request if there is one auto req = info->contacts->getTrustRequest(urih); - if (req.find(DRing::Account::TrustRequest::CONVERSATIONID) != req.end() - && req.at(DRing::Account::TrustRequest::CONVERSATIONID) == oldConv) + if (req.find(libjami::Account::TrustRequest::CONVERSATIONID) != req.end() + && req.at(libjami::Account::TrustRequest::CONVERSATIONID) == oldConv) accountManager_->discardTrustRequest(uri); } return true; @@ -3084,9 +3084,9 @@ JamiAccount::discardTrustRequest(const std::string& from) // Remove 1:1 generated conv requests auto requests = getTrustRequests(); for (const auto& req : requests) { - if (req.at(DRing::Account::TrustRequest::FROM) == from) { + if (req.at(libjami::Account::TrustRequest::FROM) == from) { convModule()->declineConversationRequest( - req.at(DRing::Account::TrustRequest::CONVERSATIONID)); + req.at(libjami::Account::TrustRequest::CONVERSATIONID)); } } @@ -3423,7 +3423,7 @@ JamiAccount::onIsComposing(const std::string& conversationId, { try { const std::string fromUri {parseJamiUri(peer)}; - emitSignal(accountID_, + emitSignal(accountID_, conversationId, peer, isWriting ? 1 : 0); @@ -3489,8 +3489,8 @@ JamiAccount::storeActiveIpAddress(std::function&& cb) void JamiAccount::requestConnection( - const DRing::DataTransferInfo& info, - const DRing::DataTransferId& tid, + const libjami::DataTransferInfo& info, + const libjami::DataTransferId& tid, bool isVCard, const std::function&)>& channeledConnectedCb, @@ -3508,7 +3508,7 @@ JamiAccount::requestConnection( } void -JamiAccount::closePeerConnection(const DRing::DataTransferId& tid) +JamiAccount::closePeerConnection(const libjami::DataTransferId& tid) { if (dhtPeerConnector_) dhtPeerConnector_->closeConnection(tid); @@ -3550,7 +3550,7 @@ JamiAccount::getUserUri() const return JAMI_URI_PREFIX + username_; } -std::vector +std::vector JamiAccount::getLastMessages(const uint64_t& base_timestamp) { return SIPAccountBase::getLastMessages(base_timestamp); @@ -3586,7 +3586,7 @@ JamiAccount::startAccountDiscovery() v.displayName.c_str(), v.accountId.to_c_str()); // Send Added Peer and corrsponding accoundID - emitSignal(getAccountID(), + emitSignal(getAccountID(), v.accountId.toString(), 0, v.displayName); @@ -3600,7 +3600,7 @@ JamiAccount::startAccountDiscovery() this_->discoveredPeerMap_.erase(p.toString()); } // Send Deleted Peer - emitSignal( + emitSignal( this_->getAccountID(), p.toString(), 1, a); } JAMI_INFO("Account removed from discovery list: %s", a.c_str()); @@ -3747,12 +3747,12 @@ JamiAccount::handleMessage(const std::string& from, const std::paironMessageDisplayed(from, conversationId, messageId)) { JAMI_DBG() << "[message " << messageId << "] Displayed by peer"; - emitSignal( + emitSignal( accountID_, conversationId, from, messageId, - static_cast(DRing::Account::MessageStates::DISPLAYED)); + static_cast(libjami::Account::MessageStates::DISPLAYED)); } } return true; @@ -4277,7 +4277,7 @@ JamiAccount::sendFile(const std::string& conversationId, }); } -DRing::DataTransferId +libjami::DataTransferId JamiAccount::sendFile(const std::string& peer, const std::string& path, const InternalCompletionCb& icb) diff --git a/src/jamidht/jamiaccount.h b/src/jamidht/jamiaccount.h index 3d5567876..6155ec665 100644 --- a/src/jamidht/jamiaccount.h +++ b/src/jamidht/jamiaccount.h @@ -265,7 +265,7 @@ public: * @return A shared pointer on the created call. */ std::shared_ptr newOutgoingCall(std::string_view toUrl, - const std::vector& mediaList) override; + const std::vector& mediaList) override; /** * Create incoming SIPCall. @@ -276,7 +276,7 @@ public: */ std::shared_ptr newIncomingCall( const std::string& from, - const std::vector& mediaList, + const std::vector& mediaList, const std::shared_ptr& sipTr = {}) override; void onTextMessage(const std::string& id, @@ -383,8 +383,8 @@ public: * @param onChanneledCancelled callback when channel is canceled */ void requestConnection( - const DRing::DataTransferInfo& info, - const DRing::DataTransferId& tid, + const libjami::DataTransferInfo& info, + const libjami::DataTransferId& tid, bool isVCard, const std::function&)>& channeledConnectedCb, @@ -396,7 +396,7 @@ public: /// /// \param[in] peer RingID on request's recipient /// /// \param[in] tid linked outgoing data transfer /// - void closePeerConnection(const DRing::DataTransferId& tid); + void closePeerConnection(const libjami::DataTransferId& tid); /// \return true if the given DHT message identifier has been treated /// \note if message has not been treated yet this method store this id and returns true at @@ -438,7 +438,7 @@ public: * Get last messages (should be used to retrieve messages when launching the client) * @param base_timestamp */ - std::vector getLastMessages(const uint64_t& base_timestamp) override; + std::vector getLastMessages(const uint64_t& base_timestamp) override; /** * Start Publish the Jami Account onto the Network @@ -467,7 +467,7 @@ public: */ void getIceOptions(std::function cb) noexcept; -#ifdef DRING_TESTABLE +#ifdef LIBJAMI_TESTABLE ConnectionManager& connectionManager() { return *connectionManager_; @@ -546,7 +546,7 @@ public: const std::string& replyTo); // non-swarm version - DRing::DataTransferId sendFile(const std::string& peer, + libjami::DataTransferId sendFile(const std::string& peer, const std::string& path, const InternalCompletionCb& icb = {}); diff --git a/src/jamidht/multiplexed_socket.cpp b/src/jamidht/multiplexed_socket.cpp index 34bd0238e..0fdb95cda 100644 --- a/src/jamidht/multiplexed_socket.cpp +++ b/src/jamidht/multiplexed_socket.cpp @@ -675,7 +675,7 @@ MultiplexedSocket::peerCertificate() const return pimpl_->endpoint->peerCertificate(); } -#ifdef DRING_TESTABLE +#ifdef LIBJAMI_TESTABLE bool MultiplexedSocket::canSendBeacon() const { @@ -1020,7 +1020,7 @@ ChannelSocket::onRecv(std::vector&& pkt) pimpl_->cv.notify_all(); } -#ifdef DRING_TESTABLE +#ifdef LIBJAMI_TESTABLE std::shared_ptr ChannelSocket::underlyingSocket() const { diff --git a/src/jamidht/multiplexed_socket.h b/src/jamidht/multiplexed_socket.h index f02e02cfb..a3cb4143b 100644 --- a/src/jamidht/multiplexed_socket.h +++ b/src/jamidht/multiplexed_socket.h @@ -138,7 +138,7 @@ public: IpAddr getLocalAddress() const; IpAddr getRemoteAddress() const; -#ifdef DRING_TESTABLE +#ifdef LIBJAMI_TESTABLE /** * Check if we can send beacon on the socket */ @@ -322,7 +322,7 @@ public: */ std::shared_ptr peerCertificate() const; -#ifdef DRING_TESTABLE +#ifdef LIBJAMI_TESTABLE std::shared_ptr underlyingSocket() const; #endif diff --git a/src/jamidht/p2p.cpp b/src/jamidht/p2p.cpp index 05524a840..12c0cb9a4 100644 --- a/src/jamidht/p2p.cpp +++ b/src/jamidht/p2p.cpp @@ -62,9 +62,9 @@ public: std::weak_ptr account; - void closeConnection(const DRing::DataTransferId& tid, const std::string& peer = ""); - void stateChanged(const DRing::DataTransferId& tid, - const DRing::DataTransferEventCode& code, + void closeConnection(const libjami::DataTransferId& tid, const std::string& peer = ""); + void stateChanged(const libjami::DataTransferId& tid, + const libjami::DataTransferEventCode& code, const std::string& peer); std::shared_ptr shared() @@ -84,7 +84,7 @@ public: return std::static_pointer_cast(shared_from_this()); } - void removeIncoming(const DRing::DataTransferId& tid, const std::string& peer) + void removeIncoming(const libjami::DataTransferId& tid, const std::string& peer) { std::vector> ifiles; { @@ -105,7 +105,7 @@ public: } } - void removeOutgoing(const DRing::DataTransferId& tid, const std::string& peer) + void removeOutgoing(const libjami::DataTransferId& tid, const std::string& peer) { std::vector> ofiles; { @@ -128,28 +128,28 @@ public: // For Channeled transports std::mutex channeledIncomingMtx_; - std::map>> + std::map>> channeledIncoming_; std::mutex channeledOutgoingMtx_; // TODO change <, Channeled> - std::map>> + std::map>> channeledOutgoing_; }; //============================================================================== void -DhtPeerConnector::Impl::stateChanged(const DRing::DataTransferId& tid, - const DRing::DataTransferEventCode& code, +DhtPeerConnector::Impl::stateChanged(const libjami::DataTransferId& tid, + const libjami::DataTransferEventCode& code, const std::string& peer) { - if (code == DRing::DataTransferEventCode::finished - or code == DRing::DataTransferEventCode::closed_by_peer - or code == DRing::DataTransferEventCode::timeout_expired) + if (code == libjami::DataTransferEventCode::finished + or code == libjami::DataTransferEventCode::closed_by_peer + or code == libjami::DataTransferEventCode::timeout_expired) closeConnection(tid, peer); } void -DhtPeerConnector::Impl::closeConnection(const DRing::DataTransferId& tid, const std::string& peer) +DhtPeerConnector::Impl::closeConnection(const libjami::DataTransferId& tid, const std::string& peer) { dht::ThreadPool::io().run([w = weak(), tid, peer] { auto shared = w.lock(); @@ -168,8 +168,8 @@ DhtPeerConnector::DhtPeerConnector(JamiAccount& account) void DhtPeerConnector::requestConnection( - const DRing::DataTransferInfo& info, - const DRing::DataTransferId& tid, + const libjami::DataTransferInfo& info, + const libjami::DataTransferId& tid, bool isVCard, const std::function&)>& channeledConnectedCb, @@ -195,8 +195,8 @@ DhtPeerConnector::requestConnection( auto outgoingFile = std::make_shared( channel, - [this, deviceId](const DRing::DataTransferId& id, - const DRing::DataTransferEventCode& code) { + [this, deviceId](const libjami::DataTransferId& id, + const libjami::DataTransferEventCode& code) { pimpl_->stateChanged(id, code, deviceId.toString()); }); if (!outgoingFile) @@ -280,14 +280,14 @@ DhtPeerConnector::requestConnection( } void -DhtPeerConnector::closeConnection(const DRing::DataTransferId& tid) +DhtPeerConnector::closeConnection(const libjami::DataTransferId& tid) { pimpl_->closeConnection(tid); } void -DhtPeerConnector::onIncomingConnection(const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, +DhtPeerConnector::onIncomingConnection(const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const std::shared_ptr& channel, const InternalCompletionCb& cb) { @@ -297,7 +297,7 @@ DhtPeerConnector::onIncomingConnection(const DRing::DataTransferInfo& info, auto incomingFile = std::make_unique( channel, std::make_shared(info, id, std::move(cb)), - [this, peer_id](const DRing::DataTransferId& id, const DRing::DataTransferEventCode& code) { + [this, peer_id](const libjami::DataTransferId& id, const libjami::DataTransferEventCode& code) { pimpl_->stateChanged(id, code, peer_id); }); { diff --git a/src/jamidht/p2p.h b/src/jamidht/p2p.h index 248bfd81b..4aa426a10 100644 --- a/src/jamidht/p2p.h +++ b/src/jamidht/p2p.h @@ -39,15 +39,15 @@ public: DhtPeerConnector(JamiAccount& account); void requestConnection( - const DRing::DataTransferInfo& info, - const DRing::DataTransferId& tid, + const libjami::DataTransferInfo& info, + const libjami::DataTransferId& tid, bool isVCard, const std::function&)>& channeledConnectedCb, const std::function& onChanneledCancelled); - void closeConnection(const DRing::DataTransferId& tid); - void onIncomingConnection(const DRing::DataTransferInfo& info, - const DRing::DataTransferId& id, + void closeConnection(const libjami::DataTransferId& tid); + void onIncomingConnection(const libjami::DataTransferInfo& info, + const libjami::DataTransferId& id, const std::shared_ptr& channel, const InternalCompletionCb& cb = {}); diff --git a/src/jamidht/server_account_manager.cpp b/src/jamidht/server_account_manager.cpp index 39bb348ca..1402380d6 100644 --- a/src/jamidht/server_account_manager.cpp +++ b/src/jamidht/server_account_manager.cpp @@ -182,7 +182,7 @@ ServerAccountManager::initAuthentication(PrivateKey key, nameServer = this_.managerHostname_ + nameServer; this_.nameDir_ = NameDirectory::instance(nameServer); config - .emplace(DRing::Account::ConfProperties::RingNS::URI, + .emplace(libjami::Account::ConfProperties::RingNS::URI, std::move(nameServer)); } else if (name == "userPhoto"sv) { this_.info_->photo = json["userPhoto"].asString(); diff --git a/src/logger.cpp b/src/logger.cpp index d26a66a55..a4566cc9b 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -426,7 +426,7 @@ public: */ auto tmp = msg.header_ + msg.payload_; - jami::emitSignal(tmp); + jami::emitSignal(tmp); } }; @@ -525,7 +525,7 @@ Logger::setFileLog(const std::string& path) FileLog::instance().setFile(path); } -DRING_PUBLIC void +LIBJAMI_PUBLIC void Logger::log(int level, const char* file, int line, bool linefeed, const char* fmt, ...) { va_list ap; diff --git a/src/logger.h b/src/logger.h index 37cfcdf80..99c136098 100644 --- a/src/logger.h +++ b/src/logger.h @@ -103,7 +103,7 @@ public: return *this; } - DRING_PUBLIC + LIBJAMI_PUBLIC static void write(int level, const char* file, int line, std::string&& message); /// @@ -111,14 +111,14 @@ public: /// /// Example: JAMI_DBG("%s", "Hello, World!") /// - DRING_PUBLIC + LIBJAMI_PUBLIC static void log(int level, const char* file, int line, bool linefeed, const char* const fmt, ...) PRINTF_ATTRIBUTE(5, 6); /// /// Printf fashion logging (using va_list parameters) /// - DRING_PUBLIC + LIBJAMI_PUBLIC static void vlog(int level, const char* file, int line, bool linefeed, const char* fmt, va_list); static void setConsoleLog(bool enable); diff --git a/src/manager.cpp b/src/manager.cpp index c5b1f8e70..6379019e7 100644 --- a/src/manager.cpp +++ b/src/manager.cpp @@ -961,7 +961,7 @@ bool Manager::hasCurrentCall() const { for (const auto& call : callFactory.getAllCalls()) { - if (!call->isSubcall() && call->getStateStr() == DRing::Call::StateEvent::CURRENT) + if (!call->isSubcall() && call->getStateStr() == libjami::Call::StateEvent::CURRENT) return true; } return false; @@ -1002,7 +1002,7 @@ Manager::unregisterAccounts() std::string Manager::outgoingCall(const std::string& account_id, const std::string& to, - const std::vector& mediaList) + const std::vector& mediaList) { JAMI_DBG() << "try outgoing call to '" << to << "'" << " with account '" << account_id << "'"; @@ -1030,7 +1030,7 @@ Manager::outgoingCall(const std::string& account_id, bool Manager::answerCall(const std::string& accountId, const std::string& callId, - const std::vector& mediaList) + const std::vector& mediaList) { if (auto account = getAccount(accountId)) { if (auto call = account->getCall(callId)) { @@ -1041,7 +1041,7 @@ Manager::answerCall(const std::string& accountId, } bool -Manager::answerCall(Call& call, const std::vector& mediaList) +Manager::answerCall(Call& call, const std::vector& mediaList) { JAMI_INFO("Answer call %s", call.getCallId().c_str()); @@ -1072,8 +1072,8 @@ Manager::answerCall(Call& call, const std::vector& mediaList) // Start recording if set in preference if (audioPreference.getIsAlwaysRecording()) { auto recResult = call.toggleRecording(); - emitSignal(call.getCallId(), call.getPath()); - emitSignal(call.getCallId(), recResult); + emitSignal(call.getCallId(), call.getPath()); + emitSignal(call.getCallId(), recResult); } return true; } @@ -1224,13 +1224,13 @@ Manager::transferCall(const std::string& accountId, const std::string& callId, c void Manager::transferFailed() { - emitSignal(); + emitSignal(); } void Manager::transferSucceeded() { - emitSignal(); + emitSignal(); } // THREAD=Main : Call:Incoming @@ -1257,7 +1257,7 @@ Manager::holdConference(const std::string& accountId, const std::string& confId) if (const auto account = getAccount(accountId)) { if (auto conf = account->getConference(confId)) { conf->detachLocalParticipant(); - emitSignal(accountId, + emitSignal(accountId, conf->getConfId(), conf->getStateStr()); return true; @@ -1281,7 +1281,7 @@ Manager::unHoldConference(const std::string& accountId, const std::string& confI pimpl_->switchCall(confId); conf->setState(Conference::State::ACTIVE_ATTACHED); - emitSignal(accountId, + emitSignal(accountId, conf->getConfId(), conf->getStateStr()); return true; @@ -1348,7 +1348,7 @@ void Manager::ManagerPimpl::addMainParticipant(Conference& conf) { conf.attachLocalParticipant(); - emitSignal(conf.getAccountId(), + emitSignal(conf.getAccountId(), conf.getConfId(), conf.getStateStr()); switchCall(conf.getConfId()); @@ -1429,7 +1429,7 @@ Manager::joinParticipant(const std::string& accountId, auto conf = std::make_shared(account); account->attach(conf); - emitSignal(account->getAccountID(), conf->getConfId()); + emitSignal(account->getAccountID(), conf->getConfId()); // Bind calls according to their state pimpl_->bindCallToConference(*call1, *conf); @@ -1442,7 +1442,7 @@ Manager::joinParticipant(const std::string& accountId, } else { conf->detachLocalParticipant(); } - emitSignal(account->getAccountID(), + emitSignal(account->getAccountID(), conf->getConfId(), conf->getStateStr()); @@ -1487,7 +1487,7 @@ Manager::createConfFromParticipantList(const std::string& accountId, // Create the conference if and only if at least 2 calls have been successfully created if (successCounter >= 2) { account->attach(conf); - emitSignal(accountId, conf->getConfId()); + emitSignal(accountId, conf->getConfId()); } } @@ -1499,7 +1499,7 @@ Manager::detachLocalParticipant(const std::shared_ptr& conf) JAMI_INFO("Detach local participant from conference %s", conf->getConfId().c_str()); conf->detachLocalParticipant(); - emitSignal(conf->getAccountId(), + emitSignal(conf->getAccountId(), conf->getConfId(), conf->getStateStr()); pimpl_->unsetCurrentCall(); @@ -1540,7 +1540,7 @@ Manager::removeParticipant(Call& call) removeAudio(call); - emitSignal(conf->getAccountId(), + emitSignal(conf->getAccountId(), conf->getConfId(), conf->getStateStr()); @@ -1848,7 +1848,7 @@ Manager::incomingCall(const std::string& accountId, Call& call) mediaList.size()); // Report the call using new API. - emitSignal(accountId, + emitSignal(accountId, call.getCallId(), call.getPeerDisplayName() + " " + from, mediaList); @@ -1884,7 +1884,7 @@ Manager::incomingMessage(const std::string& accountId, } // in case of a conference we must notify client using conference id - emitSignal(accountId, + emitSignal(accountId, conf->getConfId(), from, messages); @@ -1892,7 +1892,7 @@ Manager::incomingMessage(const std::string& accountId, JAMI_ERR("no conference associated to ID %s", callId.c_str()); } } else { - emitSignal(accountId, callId, from, messages); + emitSignal(accountId, callId, from, messages); } } } @@ -1955,8 +1955,8 @@ Manager::peerAnsweredCall(Call& call) if (audioPreference.getIsAlwaysRecording()) { auto result = call.toggleRecording(); - emitSignal(callId, call.getPath()); - emitSignal(callId, result); + emitSignal(callId, call.getPath()); + emitSignal(callId, result); } } @@ -2290,8 +2290,8 @@ Manager::toggleRecordingCall(const std::string& accountId, const std::string& id return false; } result = rec->toggleRecording(); - emitSignal(id, rec->getPath()); - emitSignal(id, result); + emitSignal(id, rec->getPath()); + emitSignal(id, result); } return result; } @@ -2532,13 +2532,13 @@ Manager::ManagerPimpl::processIncomingCall(const std::string& accountId, Call& i // First call auto conf = std::make_shared(account, false); account->attach(conf); - emitSignal(account->getAccountID(), + emitSignal(account->getAccountID(), conf->getConfId()); // Bind calls according to their state bindCallToConference(*incomCall, *conf); conf->detachLocalParticipant(); - emitSignal(account->getAccountID(), + emitSignal(account->getAccountID(), conf->getConfId(), conf->getStateStr()); }); @@ -2614,7 +2614,7 @@ Manager::setAccountsOrder(const std::string& order) saveConfig(); - emitSignal(); + emitSignal(); } std::vector @@ -2696,7 +2696,7 @@ Manager::setAccountDetails(const std::string& accountID, account->doUnregister(); // Update account details to the client side - emitSignal(accountID, details); + emitSignal(accountID, details); }); } @@ -2740,7 +2740,7 @@ Manager::addAccount(const std::map& details, const std preferences.addAccount(newAccountID); saveConfig(); - emitSignal(); + emitSignal(); return newAccountID; } @@ -2766,7 +2766,7 @@ Manager::removeAccount(const std::string& accountID, bool flush) saveConfig(); - emitSignal(); + emitSignal(); } void @@ -2953,15 +2953,15 @@ statusFromImStatus(im::MessageStatus status) switch (status) { case im::MessageStatus::IDLE: case im::MessageStatus::SENDING: - return static_cast(DRing::Account::MessageStates::SENDING); + return static_cast(libjami::Account::MessageStates::SENDING); case im::MessageStatus::SENT: - return static_cast(DRing::Account::MessageStates::SENT); + return static_cast(libjami::Account::MessageStates::SENT); case im::MessageStatus::DISPLAYED: - return static_cast(DRing::Account::MessageStates::DISPLAYED); + return static_cast(libjami::Account::MessageStates::DISPLAYED); case im::MessageStatus::FAILURE: - return static_cast(DRing::Account::MessageStates::FAILURE); + return static_cast(libjami::Account::MessageStates::FAILURE); default: - return static_cast(DRing::Account::MessageStates::UNKNOWN); + return static_cast(libjami::Account::MessageStates::UNKNOWN); } } @@ -2974,7 +2974,7 @@ Manager::getMessageStatus(uint64_t id) const if (status != im::MessageStatus::UNKNOWN) return statusFromImStatus(status); } - return static_cast(DRing::Account::MessageStates::UNKNOWN); + return static_cast(libjami::Account::MessageStates::UNKNOWN); } int @@ -2982,7 +2982,7 @@ Manager::getMessageStatus(const std::string& accountID, uint64_t id) const { if (const auto acc = getAccount(accountID)) return statusFromImStatus(acc->getMessageStatus(id)); - return static_cast(DRing::Account::MessageStates::UNKNOWN); + return static_cast(libjami::Account::MessageStates::UNKNOWN); } void @@ -3004,7 +3004,7 @@ Manager::setAccountActive(const std::string& accountID, bool active, bool shutdo } } } - emitSignal(accountID, + emitSignal(accountID, acc->getVolatileAccountDetails()); } @@ -3017,7 +3017,7 @@ Manager::getAudioDriver() std::shared_ptr Manager::newOutgoingCall(std::string_view toUrl, const std::string& accountId, - const std::vector& mediaList) + const std::vector& mediaList) { auto account = getAccount(accountId); if (not account) { @@ -3136,7 +3136,7 @@ Manager::getVideoManager() const return *pimpl_->videoManager_; } -std::vector +std::vector Manager::getLastMessages(const std::string& accountID, const uint64_t& base_timestamp) { if (const auto acc = getAccount(accountID)) diff --git a/src/manager.h b/src/manager.h index 585c1fbd6..de18e702b 100644 --- a/src/manager.h +++ b/src/manager.h @@ -69,15 +69,15 @@ class SIPVoIPLink; class JamiPluginManager; /** Manager (controller) of daemon */ -// TODO DRING_PUBLIC only if tests -class DRING_TESTABLE Manager +// TODO LIBJAMI_PUBLIC only if tests +class LIBJAMI_TESTABLE Manager { private: std::mt19937_64 rand_; public: - // TODO DRING_PUBLIC only if tests - static DRING_TESTABLE Manager& instance(); + // TODO LIBJAMI_PUBLIC only if tests + static LIBJAMI_TESTABLE Manager& instance(); void setAutoAnswer(bool enable); @@ -153,7 +153,7 @@ public: */ std::string outgoingCall(const std::string& accountId, const std::string& callee, - const std::vector& mediaList = {}); + const std::vector& mediaList = {}); /** * Functions which occur with a user's action @@ -162,8 +162,8 @@ public: */ bool answerCall(const std::string& accountId, const std::string& callId, - const std::vector& mediaList = {}); - bool answerCall(Call& call, const std::vector& mediaList = {}); + const std::vector& mediaList = {}); + bool answerCall(Call& call, const std::vector& mediaList = {}); /** * Handle incoming call and notify user @@ -779,7 +779,7 @@ public: */ std::shared_ptr newOutgoingCall(std::string_view toUrl, const std::string& accountId, - const std::vector& mediaList); + const std::vector& mediaList); CallFactory callFactory; @@ -844,7 +844,7 @@ public: std::atomic dhtLogLevel {0}; // default = disable AccountFactory accountFactory; - std::vector getLastMessages(const std::string& accountID, + std::vector getLastMessages(const std::string& accountID, const uint64_t& base_timestamp); SIPVoIPLink& sipVoIPLink() const; diff --git a/src/media/audio/alsa/alsalayer.cpp b/src/media/audio/alsa/alsalayer.cpp index faed26b72..f84ebea7f 100644 --- a/src/media/audio/alsa/alsalayer.cpp +++ b/src/media/audio/alsa/alsalayer.cpp @@ -139,7 +139,7 @@ AlsaLayer::startStream(AudioDeviceType type) SND_PCM_STREAM_PLAYBACK, audioFormat_); if (not is_playback_open_) - emitSignal(ALSA_PLAYBACK_DEVICE); + emitSignal(ALSA_PLAYBACK_DEVICE); hardwareFormatAvailable(getFormat()); startPlaybackStream(); @@ -151,7 +151,7 @@ AlsaLayer::startStream(AudioDeviceType type) buildDeviceTopo(dsnop ? PCM_DMIX : audioPlugin_, indexRing_), SND_PCM_STREAM_PLAYBACK, audioFormat_)) - emitSignal(ALSA_PLAYBACK_DEVICE); + emitSignal(ALSA_PLAYBACK_DEVICE); } if (type == AudioDeviceType::CAPTURE and not is_capture_open_) { @@ -161,7 +161,7 @@ AlsaLayer::startStream(AudioDeviceType type) audioInputFormat_); if (not is_capture_open_) - emitSignal(ALSA_CAPTURE_DEVICE); + emitSignal(ALSA_CAPTURE_DEVICE); prepareCaptureStream(); startCaptureStream(); } diff --git a/src/media/audio/audio_input.cpp b/src/media/audio/audio_input.cpp index 32dd5a203..9f54c7946 100644 --- a/src/media/audio/audio_input.cpp +++ b/src/media/audio/audio_input.cpp @@ -292,7 +292,7 @@ AudioInput::switchInput(const std::string& resource) if (initDevice("")) foundDevOpts(devOpts_); } else { - static const std::string& sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; + static const std::string& sep = libjami::Media::VideoProtocolPrefix::SEPARATOR; const auto pos = resource.find(sep); if (pos == std::string::npos) return {}; @@ -303,7 +303,7 @@ AudioInput::switchInput(const std::string& resource) const auto suffix = resource.substr(pos + sep.size()); bool ready = false; - if (prefix == DRing::Media::VideoProtocolPrefix::FILE) + if (prefix == libjami::Media::VideoProtocolPrefix::FILE) ready = initFile(suffix); else ready = initDevice(suffix); diff --git a/src/media/audio/audiolayer.cpp b/src/media/audio/audiolayer.cpp index e469667a3..c6a424a07 100644 --- a/src/media/audio/audiolayer.cpp +++ b/src/media/audio/audiolayer.cpp @@ -86,7 +86,7 @@ AudioLayer::hardwareInputFormatAvailable(AudioFormat capture) void AudioLayer::devicesChanged() { - emitSignal(); + emitSignal(); } void diff --git a/src/media/audio/opensl/opensllayer.cpp b/src/media/audio/opensl/opensllayer.cpp index a7968f7bc..f891bb5a9 100644 --- a/src/media/audio/opensl/opensllayer.cpp +++ b/src/media/audio/opensl/opensllayer.cpp @@ -174,7 +174,7 @@ OpenSLLayer::initAudioEngine() JAMI_WARN("OpenSL init started"); std::vector hw_infos; hw_infos.reserve(4); - emitSignal(&hw_infos); + emitSignal(&hw_infos); hardwareFormat_ = AudioFormat(hw_infos[0], 1); // Mono on Android hardwareBuffSize_ = hw_infos[1]; hardwareFormatAvailable(hardwareFormat_, hardwareBuffSize_); diff --git a/src/media/audio/ringbuffer.cpp b/src/media/audio/ringbuffer.cpp index 4a0e0c025..6573a25a9 100644 --- a/src/media/audio/ringbuffer.cpp +++ b/src/media/audio/ringbuffer.cpp @@ -192,7 +192,7 @@ RingBuffer::putToBuffer(std::shared_ptr&& data) ++rmsFrameCount_; rmsLevel_ += newBuf->calcRMS(); if (rmsFrameCount_ == RMS_SIGNAL_INTERVAL) { - emitSignal(id, rmsLevel_ / RMS_SIGNAL_INTERVAL); + emitSignal(id, rmsLevel_ / RMS_SIGNAL_INTERVAL); rmsLevel_ = 0; rmsFrameCount_ = 0; } diff --git a/src/media/audio/sound/audiofile.cpp b/src/media/audio/sound/audiofile.cpp index 280aecfe5..9e7b57b10 100644 --- a/src/media/audio/sound/audiofile.cpp +++ b/src/media/audio/sound/audiofile.cpp @@ -49,7 +49,7 @@ AudioFile::onBufferFinish() } if ((updatePlaybackScale_ % 5) == 0) - emitSignal(filepath_, + emitSignal(filepath_, (unsigned) (pos_ / divisor), (unsigned) (buffer_->frames() / divisor)); diff --git a/src/media/audio/tonecontrol.cpp b/src/media/audio/tonecontrol.cpp index 3c9831431..dbd0be3df 100644 --- a/src/media/audio/tonecontrol.cpp +++ b/src/media/audio/tonecontrol.cpp @@ -80,7 +80,7 @@ ToneControl::setAudioFile(const std::string& file) std::lock_guard lk(mutex_); if (audioFile_) { - emitSignal(audioFile_->getFilePath()); + emitSignal(audioFile_->getFilePath()); audioFile_.reset(); } @@ -99,7 +99,7 @@ ToneControl::stopAudioFile() std::lock_guard lk(mutex_); if (audioFile_) { - emitSignal(audioFile_->getFilePath()); + emitSignal(audioFile_->getFilePath()); audioFile_.reset(); } } @@ -113,7 +113,7 @@ ToneControl::stop() telephoneTone_->setCurrentTone(Tone::ToneId::TONE_NULL); if (audioFile_) { - emitSignal(audioFile_->getFilePath()); + emitSignal(audioFile_->getFilePath()); audioFile_.reset(); } } diff --git a/src/media/media_attribute.cpp b/src/media/media_attribute.cpp index 6ca96114d..282ab24b1 100644 --- a/src/media/media_attribute.cpp +++ b/src/media/media_attribute.cpp @@ -23,7 +23,7 @@ namespace jami { -MediaAttribute::MediaAttribute(const DRing::MediaMap& mediaMap, bool secure) +MediaAttribute::MediaAttribute(const libjami::MediaMap& mediaMap, bool secure) { std::pair pairType = getMediaType(mediaMap); if (pairType.first) @@ -31,24 +31,24 @@ MediaAttribute::MediaAttribute(const DRing::MediaMap& mediaMap, bool secure) std::pair pairBool; - pairBool = getBoolValue(mediaMap, DRing::Media::MediaAttributeKey::MUTED); + pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::MUTED); if (pairBool.first) muted_ = pairBool.second; - pairBool = getBoolValue(mediaMap, DRing::Media::MediaAttributeKey::ENABLED); + pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::ENABLED); if (pairBool.first) enabled_ = pairBool.second; std::pair pairString; - pairString = getStringValue(mediaMap, DRing::Media::MediaAttributeKey::SOURCE); + pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::SOURCE); if (pairBool.first) sourceUri_ = pairString.second; - pairString = getStringValue(mediaMap, DRing::Media::MediaAttributeKey::LABEL); + pairString = getStringValue(mediaMap, libjami::Media::MediaAttributeKey::LABEL); if (pairBool.first) label_ = pairString.second; - pairBool = getBoolValue(mediaMap, DRing::Media::MediaAttributeKey::ON_HOLD); + pairBool = getBoolValue(mediaMap, libjami::Media::MediaAttributeKey::ON_HOLD); if (pairBool.first) onHold_ = pairBool.second; @@ -56,7 +56,7 @@ MediaAttribute::MediaAttribute(const DRing::MediaMap& mediaMap, bool secure) } std::vector -MediaAttribute::buildMediaAttributesList(const std::vector& mediaList, bool secure) +MediaAttribute::buildMediaAttributesList(const std::vector& mediaList, bool secure) { std::vector mediaAttrList; mediaAttrList.reserve(mediaList.size()); @@ -71,17 +71,17 @@ MediaAttribute::buildMediaAttributesList(const std::vector& med MediaType MediaAttribute::stringToMediaType(const std::string& mediaType) { - if (mediaType.compare(DRing::Media::MediaAttributeValue::AUDIO) == 0) + if (mediaType.compare(libjami::Media::MediaAttributeValue::AUDIO) == 0) return MediaType::MEDIA_AUDIO; - if (mediaType.compare(DRing::Media::MediaAttributeValue::VIDEO) == 0) + if (mediaType.compare(libjami::Media::MediaAttributeValue::VIDEO) == 0) return MediaType::MEDIA_VIDEO; return MediaType::MEDIA_NONE; } std::pair -MediaAttribute::getMediaType(const DRing::MediaMap& map) +MediaAttribute::getMediaType(const libjami::MediaMap& map) { - const auto& iter = map.find(DRing::Media::MediaAttributeKey::MEDIA_TYPE); + const auto& iter = map.find(libjami::Media::MediaAttributeKey::MEDIA_TYPE); if (iter == map.end()) { return {false, MediaType::MEDIA_NONE}; } @@ -96,7 +96,7 @@ MediaAttribute::getMediaType(const DRing::MediaMap& map) } std::pair -MediaAttribute::getBoolValue(const DRing::MediaMap& map, const std::string& key) +MediaAttribute::getBoolValue(const libjami::MediaMap& map, const std::string& key) { const auto& iter = map.find(key); if (iter == map.end()) { @@ -114,7 +114,7 @@ MediaAttribute::getBoolValue(const DRing::MediaMap& map, const std::string& key) } std::pair -MediaAttribute::getStringValue(const DRing::MediaMap& map, const std::string& key) +MediaAttribute::getStringValue(const libjami::MediaMap& map, const std::string& key) { const auto& iter = map.find(key); if (iter == map.end()) { @@ -134,9 +134,9 @@ char const* MediaAttribute::mediaTypeToString(MediaType type) { if (type == MediaType::MEDIA_AUDIO) - return DRing::Media::MediaAttributeValue::AUDIO; + return libjami::Media::MediaAttributeValue::AUDIO; if (type == MediaType::MEDIA_VIDEO) - return DRing::Media::MediaAttributeValue::VIDEO; + return libjami::Media::MediaAttributeValue::VIDEO; return nullptr; } @@ -149,26 +149,26 @@ MediaAttribute::hasMediaType(const std::vector& mediaList, Media }); } -DRing::MediaMap +libjami::MediaMap MediaAttribute::toMediaMap(const MediaAttribute& mediaAttr) { - DRing::MediaMap mediaMap; + libjami::MediaMap mediaMap; - mediaMap.emplace(DRing::Media::MediaAttributeKey::MEDIA_TYPE, + mediaMap.emplace(libjami::Media::MediaAttributeKey::MEDIA_TYPE, mediaTypeToString(mediaAttr.type_)); - mediaMap.emplace(DRing::Media::MediaAttributeKey::LABEL, mediaAttr.label_); - mediaMap.emplace(DRing::Media::MediaAttributeKey::ENABLED, boolToString(mediaAttr.enabled_)); - mediaMap.emplace(DRing::Media::MediaAttributeKey::MUTED, boolToString(mediaAttr.muted_)); - mediaMap.emplace(DRing::Media::MediaAttributeKey::SOURCE, mediaAttr.sourceUri_); - mediaMap.emplace(DRing::Media::MediaAttributeKey::ON_HOLD, boolToString(mediaAttr.onHold_)); + mediaMap.emplace(libjami::Media::MediaAttributeKey::LABEL, mediaAttr.label_); + mediaMap.emplace(libjami::Media::MediaAttributeKey::ENABLED, boolToString(mediaAttr.enabled_)); + mediaMap.emplace(libjami::Media::MediaAttributeKey::MUTED, boolToString(mediaAttr.muted_)); + mediaMap.emplace(libjami::Media::MediaAttributeKey::SOURCE, mediaAttr.sourceUri_); + mediaMap.emplace(libjami::Media::MediaAttributeKey::ON_HOLD, boolToString(mediaAttr.onHold_)); return mediaMap; } -std::vector +std::vector MediaAttribute::mediaAttributesToMediaMaps(std::vector mediaAttrList) { - std::vector mediaList; + std::vector mediaList; mediaAttrList.reserve(mediaAttrList.size()); for (auto const& media : mediaAttrList) { mediaList.emplace_back(toMediaMap(media)); diff --git a/src/media/media_attribute.h b/src/media/media_attribute.h index af4cf61da..1c5f28b90 100644 --- a/src/media/media_attribute.h +++ b/src/media/media_attribute.h @@ -47,19 +47,19 @@ public: , onHold_(onHold) {} - MediaAttribute(const DRing::MediaMap& mediaMap, bool secure); + MediaAttribute(const libjami::MediaMap& mediaMap, bool secure); static std::vector buildMediaAttributesList( - const std::vector& mediaList, bool secure); + const std::vector& mediaList, bool secure); static MediaType stringToMediaType(const std::string& mediaType); - static std::pair getMediaType(const DRing::MediaMap& map); + static std::pair getMediaType(const libjami::MediaMap& map); - static std::pair getBoolValue(const DRing::MediaMap& mediaMap, + static std::pair getBoolValue(const libjami::MediaMap& mediaMap, const std::string& key); - static std::pair getStringValue(const DRing::MediaMap& mediaMap, + static std::pair getStringValue(const libjami::MediaMap& mediaMap, const std::string& key); // Return true if at least one media has a matching type. @@ -72,10 +72,10 @@ public: static char const* mediaTypeToString(MediaType type); // Convert MediaAttribute to MediaMap - static DRing::MediaMap toMediaMap(const MediaAttribute& mediaAttr); + static libjami::MediaMap toMediaMap(const MediaAttribute& mediaAttr); // Serialize a vector of MediaAttribute to a vector of MediaMap - static std::vector mediaAttributesToMediaMaps( + static std::vector mediaAttributesToMediaMaps( std::vector mediaAttrList); std::string toString(bool full = false) const; diff --git a/src/media/media_buffer.h b/src/media/media_buffer.h index 3752d8463..93062e908 100644 --- a/src/media/media_buffer.h +++ b/src/media/media_buffer.h @@ -29,13 +29,13 @@ namespace jami { -using MediaFrame = DRing::MediaFrame; -using AudioFrame = DRing::AudioFrame; +using MediaFrame = libjami::MediaFrame; +using AudioFrame = libjami::AudioFrame; using MediaObserver = std::function&&)>; #ifdef ENABLE_VIDEO -using VideoFrame = DRing::VideoFrame; +using VideoFrame = libjami::VideoFrame; // Some helpers int videoFrameSize(int format, int width, int height); diff --git a/src/media/media_codec.cpp b/src/media/media_codec.cpp index fdf934884..14ec86180 100644 --- a/src/media/media_codec.cpp +++ b/src/media/media_codec.cpp @@ -89,13 +89,13 @@ SystemAudioCodecInfo::~SystemAudioCodecInfo() {} std::map SystemAudioCodecInfo::getCodecSpecifications() const { - return {{DRing::Account::ConfProperties::CodecInfo::NAME, longName}, - {DRing::Account::ConfProperties::CodecInfo::TYPE, + return {{libjami::Account::ConfProperties::CodecInfo::NAME, longName}, + {libjami::Account::ConfProperties::CodecInfo::TYPE, (mediaType & MEDIA_AUDIO ? "AUDIO" : "VIDEO")}, - {DRing::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, - {DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE, + {libjami::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, + {libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE, std::to_string(audioformat.sample_rate)}, - {DRing::Account::ConfProperties::CodecInfo::CHANNEL_NUMBER, + {libjami::Account::ConfProperties::CodecInfo::CHANNEL_NUMBER, std::to_string(audioformat.nb_channels)}}; } @@ -135,13 +135,13 @@ std::map SystemVideoCodecInfo::getCodecSpecifications() const { return { - {DRing::Account::ConfProperties::CodecInfo::NAME, longName}, - {DRing::Account::ConfProperties::CodecInfo::TYPE, + {libjami::Account::ConfProperties::CodecInfo::NAME, longName}, + {libjami::Account::ConfProperties::CodecInfo::TYPE, (mediaType & MEDIA_AUDIO ? "AUDIO" : "VIDEO")}, - {DRing::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, - {DRing::Account::ConfProperties::CodecInfo::FRAME_RATE, std::to_string(frameRate)}, - {DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE, std::to_string(minBitrate)}, - {DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE, std::to_string(maxBitrate)}, + {libjami::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, + {libjami::Account::ConfProperties::CodecInfo::FRAME_RATE, std::to_string(frameRate)}, + {libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE, std::to_string(minBitrate)}, + {libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE, std::to_string(maxBitrate)}, }; } @@ -177,13 +177,13 @@ AccountAudioCodecInfo::AccountAudioCodecInfo(const SystemAudioCodecInfo& sysCode std::map AccountAudioCodecInfo::getCodecSpecifications() const { - return {{DRing::Account::ConfProperties::CodecInfo::NAME, systemCodecInfo.longName}, - {DRing::Account::ConfProperties::CodecInfo::TYPE, + return {{libjami::Account::ConfProperties::CodecInfo::NAME, systemCodecInfo.longName}, + {libjami::Account::ConfProperties::CodecInfo::TYPE, (systemCodecInfo.mediaType & MEDIA_AUDIO ? "AUDIO" : "VIDEO")}, - {DRing::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, - {DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE, + {libjami::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, + {libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE, std::to_string(audioformat.sample_rate)}, - {DRing::Account::ConfProperties::CodecInfo::CHANNEL_NUMBER, + {libjami::Account::ConfProperties::CodecInfo::CHANNEL_NUMBER, std::to_string(audioformat.nb_channels)}}; } @@ -191,10 +191,10 @@ void AccountAudioCodecInfo::setCodecSpecifications(const std::map& details) { decltype(bitrate) tmp_bitrate = jami::stoi( - details.at(DRing::Account::ConfProperties::CodecInfo::BITRATE)); + details.at(libjami::Account::ConfProperties::CodecInfo::BITRATE)); decltype(audioformat) tmp_audioformat = audioformat; tmp_audioformat.sample_rate = jami::stoi( - details.at(DRing::Account::ConfProperties::CodecInfo::SAMPLE_RATE)); + details.at(libjami::Account::ConfProperties::CodecInfo::SAMPLE_RATE)); // copy back if no exception was raised bitrate = tmp_bitrate; @@ -216,21 +216,21 @@ AccountVideoCodecInfo::AccountVideoCodecInfo(const SystemVideoCodecInfo& sysCode std::map AccountVideoCodecInfo::getCodecSpecifications() const { - return {{DRing::Account::ConfProperties::CodecInfo::NAME, systemCodecInfo.longName}, - {DRing::Account::ConfProperties::CodecInfo::TYPE, + return {{libjami::Account::ConfProperties::CodecInfo::NAME, systemCodecInfo.longName}, + {libjami::Account::ConfProperties::CodecInfo::TYPE, (systemCodecInfo.mediaType & MEDIA_AUDIO ? "AUDIO" : "VIDEO")}, - {DRing::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, - {DRing::Account::ConfProperties::CodecInfo::MAX_BITRATE, + {libjami::Account::ConfProperties::CodecInfo::BITRATE, std::to_string(bitrate)}, + {libjami::Account::ConfProperties::CodecInfo::MAX_BITRATE, std::to_string(systemCodecInfo.maxBitrate)}, - {DRing::Account::ConfProperties::CodecInfo::MIN_BITRATE, + {libjami::Account::ConfProperties::CodecInfo::MIN_BITRATE, std::to_string(systemCodecInfo.minBitrate)}, - {DRing::Account::ConfProperties::CodecInfo::QUALITY, std::to_string(quality)}, - {DRing::Account::ConfProperties::CodecInfo::MAX_QUALITY, + {libjami::Account::ConfProperties::CodecInfo::QUALITY, std::to_string(quality)}, + {libjami::Account::ConfProperties::CodecInfo::MAX_QUALITY, std::to_string(systemCodecInfo.maxQuality)}, - {DRing::Account::ConfProperties::CodecInfo::MIN_QUALITY, + {libjami::Account::ConfProperties::CodecInfo::MIN_QUALITY, std::to_string(systemCodecInfo.minQuality)}, - {DRing::Account::ConfProperties::CodecInfo::FRAME_RATE, std::to_string(frameRate)}, - {DRing::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED, + {libjami::Account::ConfProperties::CodecInfo::FRAME_RATE, std::to_string(frameRate)}, + {libjami::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED, bool_to_str(isAutoQualityEnabled)}}; } @@ -239,19 +239,19 @@ AccountVideoCodecInfo::setCodecSpecifications(const std::mapsecond); - it = details.find(DRing::Account::ConfProperties::CodecInfo::FRAME_RATE); + it = details.find(libjami::Account::ConfProperties::CodecInfo::FRAME_RATE); if (it != details.end()) copy.frameRate = jami::stoi(it->second); - it = details.find(DRing::Account::ConfProperties::CodecInfo::QUALITY); + it = details.find(libjami::Account::ConfProperties::CodecInfo::QUALITY); if (it != details.end()) copy.quality = jami::stoi(it->second); - it = details.find(DRing::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED); + it = details.find(libjami::Account::ConfProperties::CodecInfo::AUTO_QUALITY_ENABLED); if (it != details.end()) copy.isAutoQualityEnabled = (it->second == TRUE_STR) ? true : false; diff --git a/src/media/media_decoder.cpp b/src/media/media_decoder.cpp index cd1698a50..cc8ad30f4 100644 --- a/src/media/media_decoder.cpp +++ b/src/media/media_decoder.cpp @@ -726,7 +726,7 @@ void MediaDecoder::enableAccel(bool enableAccel) { enableAccel_ = enableAccel; - emitSignal(enableAccel_); + emitSignal(enableAccel_); if (!enableAccel) { accel_.reset(); if (decoderCtx_) diff --git a/src/media/media_decoder.h b/src/media/media_decoder.h index 55e15ae7b..34c22e398 100644 --- a/src/media/media_decoder.h +++ b/src/media/media_decoder.h @@ -55,15 +55,15 @@ struct AVCodec; enum AVMediaType; } -namespace DRing { +namespace libjami { class AudioFrame; } namespace jami { -using AudioFrame = DRing::AudioFrame; +using AudioFrame = libjami::AudioFrame; #ifdef ENABLE_VIDEO -using VideoFrame = DRing::VideoFrame; +using VideoFrame = libjami::VideoFrame; #endif struct AudioFormat; class RingBuffer; diff --git a/src/media/media_encoder.cpp b/src/media/media_encoder.cpp index 024132fda..1470374e3 100644 --- a/src/media/media_encoder.cpp +++ b/src/media/media_encoder.cpp @@ -741,7 +741,7 @@ void MediaEncoder::enableAccel(bool enableAccel) { enableAccel_ = enableAccel; - emitSignal(enableAccel_); + emitSignal(enableAccel_); if (!enableAccel_) { accel_.reset(); for (auto enc : encoders_) diff --git a/src/media/media_filter.cpp b/src/media/media_filter.cpp index c5423d169..c2bbf767d 100644 --- a/src/media/media_filter.cpp +++ b/src/media/media_filter.cpp @@ -201,7 +201,7 @@ MediaFilter::readOutput() switch (av_buffersink_get_type(output_)) { #ifdef ENABLE_VIDEO case AVMEDIA_TYPE_VIDEO: - frame = std::make_unique(); + frame = std::make_unique(); break; #endif case AVMEDIA_TYPE_AUDIO: diff --git a/src/media/media_player.cpp b/src/media/media_player.cpp index 2d719b39c..2967fc468 100644 --- a/src/media/media_player.cpp +++ b/src/media/media_player.cpp @@ -33,7 +33,7 @@ MediaPlayer::MediaPlayer(const std::string& path) std::bind(&MediaPlayer::process, this), [] {}) { - static const std::string& sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; + static const std::string& sep = libjami::Media::VideoProtocolPrefix::SEPARATOR; const auto pos = path.find(sep); const auto suffix = path.substr(pos + sep.size()); @@ -165,7 +165,7 @@ MediaPlayer::emitInfo() std::map info {{"duration", std::to_string(fileDuration_)}, {"audio_stream", std::to_string(audioStream_)}, {"video_stream", std::to_string(videoStream_)}}; - emitSignal(id_, info); + emitSignal(id_, info); } bool diff --git a/src/media/media_recorder.cpp b/src/media/media_recorder.cpp index a92d55699..3fd4f7212 100644 --- a/src/media/media_recorder.cpp +++ b/src/media/media_recorder.cpp @@ -219,7 +219,7 @@ MediaRecorder::stopRecording() if (isRecording_) { JAMI_DBG() << "Stop recording '" << getPath() << "'"; isRecording_ = false; - emitSignal(getPath()); + emitSignal(getPath()); } } diff --git a/src/media/video/androidvideo/video_device_impl.cpp b/src/media/video/androidvideo/video_device_impl.cpp index 59a768122..901916c06 100644 --- a/src/media/video/androidvideo/video_device_impl.cpp +++ b/src/media/video/androidvideo/video_device_impl.cpp @@ -120,7 +120,7 @@ VideoDeviceImpl::VideoDeviceImpl(const std::string& path) formats_.reserve(16); sizes.reserve(16); rates.reserve(16); - emitSignal(name, &formats_, &sizes, &rates); + emitSignal(name, &formats_, &sizes, &rates); for (size_t i = 0, n = sizes.size(); i < n; i += 2) sizes_.emplace_back(sizes[i], sizes[i + 1]); for (const auto& r : rates) @@ -183,7 +183,7 @@ VideoDeviceImpl::setDeviceParams(const DeviceParams& params) { size_ = getSize({params.width, params.height}); rate_ = getRate(params.framerate); - emitSignal(name, + emitSignal(name, fmt_->code, size_.first, size_.second, diff --git a/src/media/video/iosvideo/video_device_impl.cpp b/src/media/video/iosvideo/video_device_impl.cpp index e10e2e967..60912a965 100644 --- a/src/media/video/iosvideo/video_device_impl.cpp +++ b/src/media/video/iosvideo/video_device_impl.cpp @@ -168,7 +168,7 @@ VideoDeviceImpl::setDeviceParams(const DeviceParams& params) { size_ = getSize({params.width, params.height}); rate_ = getRate(params.framerate); - emitSignal(name); + emitSignal(name); } VideoDevice::VideoDevice(const std::string& path, diff --git a/src/media/video/sinkclient.cpp b/src/media/video/sinkclient.cpp index 480a668a6..9b5d2545c 100644 --- a/src/media/video/sinkclient.cpp +++ b/src/media/video/sinkclient.cpp @@ -341,7 +341,7 @@ SinkClient::sendFrameDirect(const std::shared_ptr& frame_p) { notify(frame_p); - DRing::FrameBuffer outFrame(av_frame_alloc()); + libjami::FrameBuffer outFrame(av_frame_alloc()); av_frame_ref(outFrame.get(), std::static_pointer_cast(frame_p)->pointer()); if (crop_.w || crop_.h) { outFrame->crop_top = crop_.y; @@ -476,7 +476,7 @@ SinkClient::setFrameSize(int width, int height) width, height, mixer_ ? "Yes" : "No"); - emitSignal(getId(), openedName(), width, height, mixer_); + emitSignal(getId(), openedName(), width, height, mixer_); started_ = true; } else if (started_) { JAMI_DBG("[Sink:%p] Stopped - size=%dx%d, mixer=%s", @@ -484,7 +484,7 @@ SinkClient::setFrameSize(int width, int height) width, height, mixer_ ? "Yes" : "No"); - emitSignal(getId(), openedName(), mixer_); + emitSignal(getId(), openedName(), mixer_); started_ = false; } } diff --git a/src/media/video/sinkclient.h b/src/media/video/sinkclient.h index adce5090c..eaa7fc5e4 100644 --- a/src/media/video/sinkclient.h +++ b/src/media/video/sinkclient.h @@ -76,7 +76,7 @@ public: void setFrameSize(int width, int height); void setCrop(int x, int y, int w, int h); - void registerTarget(DRing::SinkTarget target) noexcept + void registerTarget(libjami::SinkTarget target) noexcept { std::lock_guard lock(mtx_); target_ = std::move(target); @@ -101,7 +101,7 @@ private: bool started_ {false}; // used to arbitrate client's stop signal. int rotation_ {0}; - DRing::SinkTarget target_; + libjami::SinkTarget target_; std::unique_ptr scaler_; std::unique_ptr filter_; std::mutex mtx_; diff --git a/src/media/video/uwpvideo/video_device_impl.cpp b/src/media/video/uwpvideo/video_device_impl.cpp index 72b08b9f2..ff9cd5a2c 100644 --- a/src/media/video/uwpvideo/video_device_impl.cpp +++ b/src/media/video/uwpvideo/video_device_impl.cpp @@ -169,7 +169,7 @@ VideoDeviceImpl::setDeviceParams(const DeviceParams& params) { size_ = getSize({params.width, params.height}); rate_ = getRate(params.framerate); - emitSignal(name); + emitSignal(name); } VideoDevice::VideoDevice(const std::string& path, diff --git a/src/media/video/video_base.h b/src/media/video/video_base.h index 587ae9ee4..4ce5cc11c 100644 --- a/src/media/video/video_base.h +++ b/src/media/video/video_base.h @@ -48,14 +48,14 @@ struct AVIOContext; #endif } -namespace DRing { +namespace libjami { class MediaFrame; class VideoFrame; -} // namespace DRing +} // namespace libjami namespace jami { -using MediaFrame = DRing::MediaFrame; -using VideoFrame = DRing::VideoFrame; +using MediaFrame = libjami::MediaFrame; +using VideoFrame = libjami::VideoFrame; } // namespace jami namespace jami { diff --git a/src/media/video/video_device.h b/src/media/video/video_device.h index 27d944c04..e6b1f0a09 100644 --- a/src/media/video/video_device.h +++ b/src/media/video/video_device.h @@ -78,9 +78,9 @@ public: * '800x448': ['15'], * '960x540': ['10']}} */ - DRing::VideoCapabilities getCapabilities() const + libjami::VideoCapabilities getCapabilities() const { - DRing::VideoCapabilities cap; + libjami::VideoCapabilities cap; for (const auto& chan : getChannelList()) for (const auto& size : getSizeList(chan)) { diff --git a/src/media/video/video_device_monitor.cpp b/src/media/video/video_device_monitor.cpp index d784b5dc8..ae9c24dd2 100644 --- a/src/media/video/video_device_monitor.cpp +++ b/src/media/video/video_device_monitor.cpp @@ -59,13 +59,13 @@ VideoDeviceMonitor::getDeviceList() const return ids; } -DRing::VideoCapabilities +libjami::VideoCapabilities VideoDeviceMonitor::getCapabilities(const string& id) const { std::lock_guard l(lock_); const auto iter = findDeviceById(id); if (iter == devices_.end()) - return DRing::VideoCapabilities(); + return libjami::VideoCapabilities(); return iter->getCapabilities(); } @@ -114,8 +114,8 @@ VideoDeviceMonitor::getMRLForDefaultDevice() const const auto it = findDeviceById(defaultDevice_); if (it == std::end(devices_) || it->getDeviceId() == DEVICE_DESKTOP) return {}; - static const std::string sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; - return DRing::Media::VideoProtocolPrefix::CAMERA + sep + it->getDeviceId(); + static const std::string sep = libjami::Media::VideoProtocolPrefix::SEPARATOR; + return libjami::Media::VideoProtocolPrefix::CAMERA + sep + it->getDeviceId(); } bool @@ -183,7 +183,7 @@ static void notify() { if (Manager::initialized) { - emitSignal(); + emitSignal(); } } diff --git a/src/media/video/video_device_monitor.h b/src/media/video/video_device_monitor.h index bd17b88b9..1037d4a9c 100644 --- a/src/media/video/video_device_monitor.h +++ b/src/media/video/video_device_monitor.h @@ -50,7 +50,7 @@ public: std::vector getDeviceList() const; - DRing::VideoCapabilities getCapabilities(const std::string& name) const; + libjami::VideoCapabilities getCapabilities(const std::string& name) const; VideoSettings getSettings(const std::string& name); void applySettings(const std::string& name, const VideoSettings& settings); diff --git a/src/media/video/video_input.cpp b/src/media/video/video_input.cpp index d7c08c129..aacf8a3f5 100644 --- a/src/media/video/video_input.cpp +++ b/src/media/video/video_input.cpp @@ -83,7 +83,7 @@ VideoInput::~VideoInput() { isStopped_ = true; if (videoManagedByClient()) { - emitSignal(decOpts_.input); + emitSignal(decOpts_.input); capturing_ = false; return; } @@ -111,7 +111,7 @@ VideoInput::switchDevice() return; } - emitSignal(decOpts_.input); + emitSignal(decOpts_.input); capturing_ = true; } } @@ -567,7 +567,7 @@ VideoInput::switchInput(const std::string& resource) } // Supported MRL schemes - static const std::string sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; + static const std::string sep = libjami::Media::VideoProtocolPrefix::SEPARATOR; const auto pos = resource.find(sep); if (pos == std::string::npos) @@ -581,10 +581,10 @@ VideoInput::switchInput(const std::string& resource) bool ready = false; - if (prefix == DRing::Media::VideoProtocolPrefix::CAMERA) { + if (prefix == libjami::Media::VideoProtocolPrefix::CAMERA) { /* Video4Linux2 */ ready = initCamera(suffix); - } else if (prefix == DRing::Media::VideoProtocolPrefix::DISPLAY) { + } else if (prefix == libjami::Media::VideoProtocolPrefix::DISPLAY) { /* X11 display name */ #ifdef __APPLE__ ready = initAVFoundation(suffix); @@ -593,7 +593,7 @@ VideoInput::switchInput(const std::string& resource) #else ready = initX11(suffix); #endif - } else if (prefix == DRing::Media::VideoProtocolPrefix::FILE) { + } else if (prefix == libjami::Media::VideoProtocolPrefix::FILE) { /* Pathname */ ready = initFile(suffix); } diff --git a/src/media/video/video_rtp_session.cpp b/src/media/video/video_rtp_session.cpp index 4f3efb1f8..b59e8a0d4 100644 --- a/src/media/video/video_rtp_session.cpp +++ b/src/media/video/video_rtp_session.cpp @@ -440,7 +440,7 @@ VideoRtpSession::forceKeyFrame() std::lock_guard lock(mutex_); #if __ANDROID__ if (videoLocal_) - emitSignal(videoLocal_->getName()); + emitSignal(videoLocal_->getName()); #else if (sender_) sender_->forceKeyFrame(); @@ -677,7 +677,7 @@ VideoRtpSession::setNewBitrate(unsigned int newBR) #if __ANDROID__ if (auto input_device = std::dynamic_pointer_cast(videoLocal_)) - emitSignal(input_device->getConfig().name, (int) newBR); + emitSignal(input_device->getConfig().name, (int) newBR); #endif if (sender_) { diff --git a/src/peer_connection.h b/src/peer_connection.h index 72da21fb3..8b696bc18 100644 --- a/src/peer_connection.h +++ b/src/peer_connection.h @@ -62,7 +62,7 @@ class Stream public: virtual ~Stream() { close(); } virtual void close() noexcept {} - virtual DRing::DataTransferId getId() const = 0; + virtual libjami::DataTransferId getId() const = 0; virtual bool write(std::string_view) { return false; }; virtual void setOnRecv(std::function&&) { diff --git a/src/plugin/jamipluginmanager.cpp b/src/plugin/jamipluginmanager.cpp index 5c078b5cf..711614b88 100644 --- a/src/plugin/jamipluginmanager.cpp +++ b/src/plugin/jamipluginmanager.cpp @@ -142,7 +142,7 @@ JamiPluginManager::installPlugin(const std::string& jplPath, bool force) destinationDir, PluginUtils::uncompressJplFunction); } - DRing::loadPlugin(destinationDir); + libjami::loadPlugin(destinationDir); } catch (const std::exception& e) { JAMI_ERR() << e.what(); } @@ -159,7 +159,7 @@ JamiPluginManager::uninstallPlugin(const std::string& rootPath) bool loaded = pm_.checkLoadedPlugin(rootPath); if (loaded) { JAMI_INFO() << "PLUGIN: unloading before uninstall."; - bool status = DRing::unloadPlugin(rootPath); + bool status = libjami::unloadPlugin(rootPath); if (!status) { JAMI_INFO() << "PLUGIN: could not unload, not performing uninstall."; return -1; diff --git a/src/plugin/webviewservicesmanager.cpp b/src/plugin/webviewservicesmanager.cpp index 516ccaf0f..fa84fbab7 100644 --- a/src/plugin/webviewservicesmanager.cpp +++ b/src/plugin/webviewservicesmanager.cpp @@ -115,7 +115,7 @@ WebViewServicesManager::registerWebViewService(PluginManager& pluginManager) // get datapath for the plugin const std::string& dataPath = PluginUtils::dataPath(plugin->getPath()); - emitSignal(dataPath, + emitSignal(dataPath, message->webViewId, message->messageId, message->payload); diff --git a/src/preferences.cpp b/src/preferences.cpp index 649dd612a..af8df3441 100644 --- a/src/preferences.cpp +++ b/src/preferences.cpp @@ -104,7 +104,7 @@ static constexpr const char* PULSEMAP_KEY {"pulse"}; static constexpr const char* PORTAUDIO_KEY {"portaudio"}; static constexpr const char* CARDIN_KEY {"cardIn"}; static constexpr const char* CARDOUT_KEY {"cardOut"}; -static constexpr const char* CARDRING_KEY {"cardRing"}; +static constexpr const char* CARLIBJAMI_KEY {"cardRing"}; static constexpr const char* PLUGIN_KEY {"plugin"}; static constexpr const char* SMPLRATE_KEY {"smplRate"}; static constexpr const char* DEVICE_PLAYBACK_KEY {"devicePlayback"}; @@ -409,7 +409,7 @@ AudioPreference::serialize(YAML::Emitter& out) const out << YAML::Key << ALSAMAP_KEY << YAML::Value << YAML::BeginMap; out << YAML::Key << CARDIN_KEY << YAML::Value << alsaCardin_; out << YAML::Key << CARDOUT_KEY << YAML::Value << alsaCardout_; - out << YAML::Key << CARDRING_KEY << YAML::Value << alsaCardRingtone_; + out << YAML::Key << CARLIBJAMI_KEY << YAML::Value << alsaCardRingtone_; out << YAML::Key << PLUGIN_KEY << YAML::Value << alsaPlugin_; out << YAML::Key << SMPLRATE_KEY << YAML::Value << alsaSmplrate_; out << YAML::EndMap; @@ -471,7 +471,7 @@ AudioPreference::unserialize(const YAML::Node& in) parseValue(alsa, CARDIN_KEY, alsaCardin_); parseValue(alsa, CARDOUT_KEY, alsaCardout_); - parseValue(alsa, CARDRING_KEY, alsaCardRingtone_); + parseValue(alsa, CARLIBJAMI_KEY, alsaCardRingtone_); parseValue(alsa, PLUGIN_KEY, alsaPlugin_); parseValue(alsa, SMPLRATE_KEY, alsaSmplrate_); diff --git a/src/preferences.h b/src/preferences.h index 452f4d506..8cd4ef99f 100644 --- a/src/preferences.h +++ b/src/preferences.h @@ -289,7 +289,7 @@ public: { if (decodingAccelerated_ != decodingAccelerated) { decodingAccelerated_ = decodingAccelerated; - emitSignal(decodingAccelerated_); + emitSignal(decodingAccelerated_); return true; } return false; @@ -301,7 +301,7 @@ public: { if (encodingAccelerated_ != encodingAccelerated) { encodingAccelerated_ = encodingAccelerated; - emitSignal(encodingAccelerated_); + emitSignal(encodingAccelerated_); return true; } return false; diff --git a/src/ring_api.cpp b/src/ring_api.cpp index 1def4167f..b88aa20a6 100644 --- a/src/ring_api.cpp +++ b/src/ring_api.cpp @@ -39,15 +39,15 @@ #include "client/videomanager.h" #endif // ENABLE_VIDEO -namespace DRing { +namespace libjami { bool init(enum InitFlag flags) noexcept { - jami::Logger::setDebugMode(DRING_FLAG_DEBUG == (flags & DRING_FLAG_DEBUG)); + jami::Logger::setDebugMode(LIBJAMI_FLAG_DEBUG == (flags & LIBJAMI_FLAG_DEBUG)); jami::Logger::setSysLog(true); - jami::Logger::setConsoleLog(DRING_FLAG_CONSOLE_LOG == (flags & DRING_FLAG_CONSOLE_LOG)); + jami::Logger::setConsoleLog(LIBJAMI_FLAG_CONSOLE_LOG == (flags & LIBJAMI_FLAG_CONSOLE_LOG)); const char* log_file = getenv("JAMI_LOG_FILE"); @@ -63,10 +63,10 @@ init(enum InitFlag flags) noexcept try { // current implementation use static variable auto& manager = jami::Manager::instance(); - manager.setAutoAnswer(flags & DRING_FLAG_AUTOANSWER); + manager.setAutoAnswer(flags & LIBJAMI_FLAG_AUTOANSWER); #if TARGET_OS_IOS - if (flags & DRING_FLAG_IOS_EXTENSION) + if (flags & LIBJAMI_FLAG_IOS_EXTENSION) manager.isIOSExtension = true; #endif @@ -116,4 +116,4 @@ logging(const std::string& whom, const std::string& action) noexcept } } -} // namespace DRing +} // namespace libjami diff --git a/src/security/certstore.cpp b/src/security/certstore.cpp index bfb4d2d4f..390d026ed 100644 --- a/src/security/certstore.cpp +++ b/src/security/certstore.cpp @@ -281,7 +281,7 @@ CertificateStore::pinCertificatePath(const std::string& path, JAMI_DBG("CertificateStore: loaded %zu certificates from %s.", certs.size(), path.c_str()); if (cb) cb(ids); - emitSignal(path, ids); + emitSignal(path, ids); }); } @@ -354,7 +354,7 @@ CertificateStore::pinCertificate(const std::shared_ptr& cer } } for (const auto& id : ids) - emitSignal(id); + emitSignal(id); return ids; } @@ -460,9 +460,9 @@ CertificateStore::pinOcspResponse(const dht::crypto::Certificate& cert) TrustStore::PermissionStatus TrustStore::statusFromStr(const char* str) { - if (!std::strcmp(str, DRing::Certificate::Status::ALLOWED)) + if (!std::strcmp(str, libjami::Certificate::Status::ALLOWED)) return PermissionStatus::ALLOWED; - if (!std::strcmp(str, DRing::Certificate::Status::BANNED)) + if (!std::strcmp(str, libjami::Certificate::Status::BANNED)) return PermissionStatus::BANNED; return PermissionStatus::UNDEFINED; } @@ -472,19 +472,19 @@ TrustStore::statusToStr(TrustStore::PermissionStatus s) { switch (s) { case PermissionStatus::ALLOWED: - return DRing::Certificate::Status::ALLOWED; + return libjami::Certificate::Status::ALLOWED; case PermissionStatus::BANNED: - return DRing::Certificate::Status::BANNED; + return libjami::Certificate::Status::BANNED; case PermissionStatus::UNDEFINED: default: - return DRing::Certificate::Status::UNDEFINED; + return libjami::Certificate::Status::UNDEFINED; } } TrustStatus trustStatusFromStr(const char* str) { - if (!std::strcmp(str, DRing::Certificate::TrustStatus::TRUSTED)) + if (!std::strcmp(str, libjami::Certificate::TrustStatus::TRUSTED)) return TrustStatus::TRUSTED; return TrustStatus::UNTRUSTED; } @@ -494,10 +494,10 @@ statusToStr(TrustStatus s) { switch (s) { case TrustStatus::TRUSTED: - return DRing::Certificate::TrustStatus::TRUSTED; + return libjami::Certificate::TrustStatus::TRUSTED; case TrustStatus::UNTRUSTED: default: - return DRing::Certificate::TrustStatus::UNTRUSTED; + return libjami::Certificate::TrustStatus::UNTRUSTED; } } diff --git a/src/security/tlsvalidator.cpp b/src/security/tlsvalidator.cpp index db535c479..90f994404 100644 --- a/src/security/tlsvalidator.cpp +++ b/src/security/tlsvalidator.cpp @@ -73,12 +73,12 @@ namespace tls { const EnumClassNames TlsValidator::CheckValuesNames = {{ /* CheckValues Name */ - /* PASSED */ DRing::Certificate::CheckValuesNames::PASSED, - /* FAILED */ DRing::Certificate::CheckValuesNames::FAILED, - /* UNSUPPORTED */ DRing::Certificate::CheckValuesNames::UNSUPPORTED, - /* ISO_DATE */ DRing::Certificate::CheckValuesNames::ISO_DATE, - /* CUSTOM */ DRing::Certificate::CheckValuesNames::CUSTOM, - /* CUSTOM */ DRing::Certificate::CheckValuesNames::DATE, + /* PASSED */ libjami::Certificate::CheckValuesNames::PASSED, + /* FAILED */ libjami::Certificate::CheckValuesNames::FAILED, + /* UNSUPPORTED */ libjami::Certificate::CheckValuesNames::UNSUPPORTED, + /* ISO_DATE */ libjami::Certificate::CheckValuesNames::ISO_DATE, + /* CUSTOM */ libjami::Certificate::CheckValuesNames::CUSTOM, + /* CUSTOM */ libjami::Certificate::CheckValuesNames::DATE, }}; const CallbackMatrix1D @@ -158,58 +158,58 @@ const Matrix1D const EnumClassNames TlsValidator::CertificateCheckNames = {{ /* CertificateCheck Name */ - /*HAS_PRIVATE_KEY */ DRing::Certificate::ChecksNames::HAS_PRIVATE_KEY, - /*EXPIRED */ DRing::Certificate::ChecksNames::EXPIRED, - /*STRONG_SIGNING */ DRing::Certificate::ChecksNames::STRONG_SIGNING, - /*NOT_SELF_SIGNED */ DRing::Certificate::ChecksNames::NOT_SELF_SIGNED, - /*KEY_MATCH */ DRing::Certificate::ChecksNames::KEY_MATCH, - /*PRIVATE_KEY_STORAGE_PERMISSION */ DRing::Certificate::ChecksNames::PRIVATE_KEY_STORAGE_PERMISSION, - /*PUBLIC_KEY_STORAGE_PERMISSION */ DRing::Certificate::ChecksNames::PUBLIC_KEY_STORAGE_PERMISSION, - /*PRIVATEKEY_DIRECTORY_PERMISSIONS */ DRing::Certificate::ChecksNames::PRIVATE_KEY_DIRECTORY_PERMISSIONS, - /*PUBLICKEY_DIRECTORY_PERMISSIONS */ DRing::Certificate::ChecksNames::PUBLIC_KEY_DIRECTORY_PERMISSIONS, - /*PRIVATE_KEY_STORAGE_LOCATION */ DRing::Certificate::ChecksNames::PRIVATE_KEY_STORAGE_LOCATION, - /*PUBLIC_KEY_STORAGE_LOCATION */ DRing::Certificate::ChecksNames::PUBLIC_KEY_STORAGE_LOCATION, - /*PRIVATE_KEY_SELINUX_ATTRIBUTES */ DRing::Certificate::ChecksNames::PRIVATE_KEY_SELINUX_ATTRIBUTES, - /*PUBLIC_KEY_SELINUX_ATTRIBUTES */ DRing::Certificate::ChecksNames::PUBLIC_KEY_SELINUX_ATTRIBUTES, - /*EXIST */ DRing::Certificate::ChecksNames::EXIST, - /*VALID */ DRing::Certificate::ChecksNames::VALID, - /*VALID_AUTHORITY */ DRing::Certificate::ChecksNames::VALID_AUTHORITY, - /*KNOWN_AUTHORITY */ DRing::Certificate::ChecksNames::KNOWN_AUTHORITY, - /*NOT_REVOKED */ DRing::Certificate::ChecksNames::NOT_REVOKED, - /*AUTHORITY_MISMATCH */ DRing::Certificate::ChecksNames::AUTHORITY_MISMATCH, - /*UNEXPECTED_OWNER */ DRing::Certificate::ChecksNames::UNEXPECTED_OWNER, - /*NOT_ACTIVATED */ DRing::Certificate::ChecksNames::NOT_ACTIVATED, + /*HAS_PRIVATE_KEY */ libjami::Certificate::ChecksNames::HAS_PRIVATE_KEY, + /*EXPIRED */ libjami::Certificate::ChecksNames::EXPIRED, + /*STRONG_SIGNING */ libjami::Certificate::ChecksNames::STRONG_SIGNING, + /*NOT_SELF_SIGNED */ libjami::Certificate::ChecksNames::NOT_SELF_SIGNED, + /*KEY_MATCH */ libjami::Certificate::ChecksNames::KEY_MATCH, + /*PRIVATE_KEY_STORAGE_PERMISSION */ libjami::Certificate::ChecksNames::PRIVATE_KEY_STORAGE_PERMISSION, + /*PUBLIC_KEY_STORAGE_PERMISSION */ libjami::Certificate::ChecksNames::PUBLIC_KEY_STORAGE_PERMISSION, + /*PRIVATEKEY_DIRECTORY_PERMISSIONS */ libjami::Certificate::ChecksNames::PRIVATE_KEY_DIRECTORY_PERMISSIONS, + /*PUBLICKEY_DIRECTORY_PERMISSIONS */ libjami::Certificate::ChecksNames::PUBLIC_KEY_DIRECTORY_PERMISSIONS, + /*PRIVATE_KEY_STORAGE_LOCATION */ libjami::Certificate::ChecksNames::PRIVATE_KEY_STORAGE_LOCATION, + /*PUBLIC_KEY_STORAGE_LOCATION */ libjami::Certificate::ChecksNames::PUBLIC_KEY_STORAGE_LOCATION, + /*PRIVATE_KEY_SELINUX_ATTRIBUTES */ libjami::Certificate::ChecksNames::PRIVATE_KEY_SELINUX_ATTRIBUTES, + /*PUBLIC_KEY_SELINUX_ATTRIBUTES */ libjami::Certificate::ChecksNames::PUBLIC_KEY_SELINUX_ATTRIBUTES, + /*EXIST */ libjami::Certificate::ChecksNames::EXIST, + /*VALID */ libjami::Certificate::ChecksNames::VALID, + /*VALID_AUTHORITY */ libjami::Certificate::ChecksNames::VALID_AUTHORITY, + /*KNOWN_AUTHORITY */ libjami::Certificate::ChecksNames::KNOWN_AUTHORITY, + /*NOT_REVOKED */ libjami::Certificate::ChecksNames::NOT_REVOKED, + /*AUTHORITY_MISMATCH */ libjami::Certificate::ChecksNames::AUTHORITY_MISMATCH, + /*UNEXPECTED_OWNER */ libjami::Certificate::ChecksNames::UNEXPECTED_OWNER, + /*NOT_ACTIVATED */ libjami::Certificate::ChecksNames::NOT_ACTIVATED, }}; const EnumClassNames TlsValidator::CertificateDetailsNames = {{ - /* EXPIRATION_DATE */ DRing::Certificate::DetailsNames::EXPIRATION_DATE, - /* ACTIVATION_DATE */ DRing::Certificate::DetailsNames::ACTIVATION_DATE, - /* REQUIRE_PRIVATE_KEY_PASSWORD */ DRing::Certificate::DetailsNames::REQUIRE_PRIVATE_KEY_PASSWORD, - /* PUBLIC_SIGNATURE */ DRing::Certificate::DetailsNames::PUBLIC_SIGNATURE, - /* VERSION_NUMBER */ DRing::Certificate::DetailsNames::VERSION_NUMBER, - /* SERIAL_NUMBER */ DRing::Certificate::DetailsNames::SERIAL_NUMBER, - /* ISSUER */ DRing::Certificate::DetailsNames::ISSUER, - /* SUBJECT_KEY_ALGORITHM */ DRing::Certificate::DetailsNames::SUBJECT_KEY_ALGORITHM, - /* CN */ DRing::Certificate::DetailsNames::CN, - /* N */ DRing::Certificate::DetailsNames::N, - /* O */ DRing::Certificate::DetailsNames::O, - /* SIGNATURE_ALGORITHM */ DRing::Certificate::DetailsNames::SIGNATURE_ALGORITHM, - /* MD5_FINGERPRINT */ DRing::Certificate::DetailsNames::MD5_FINGERPRINT, - /* SHA1_FINGERPRINT */ DRing::Certificate::DetailsNames::SHA1_FINGERPRINT, - /* PUBLIC_KEY_ID */ DRing::Certificate::DetailsNames::PUBLIC_KEY_ID, - /* ISSUER_DN */ DRing::Certificate::DetailsNames::ISSUER_DN, - /* NEXT_EXPECTED_UPDATE_DATE */ DRing::Certificate::DetailsNames::NEXT_EXPECTED_UPDATE_DATE, - /* OUTGOING_SERVER */ DRing::Certificate::DetailsNames::OUTGOING_SERVER, - /* IS_CA */ DRing::Certificate::DetailsNames::IS_CA, + /* EXPIRATION_DATE */ libjami::Certificate::DetailsNames::EXPIRATION_DATE, + /* ACTIVATION_DATE */ libjami::Certificate::DetailsNames::ACTIVATION_DATE, + /* REQUIRE_PRIVATE_KEY_PASSWORD */ libjami::Certificate::DetailsNames::REQUIRE_PRIVATE_KEY_PASSWORD, + /* PUBLIC_SIGNATURE */ libjami::Certificate::DetailsNames::PUBLIC_SIGNATURE, + /* VERSION_NUMBER */ libjami::Certificate::DetailsNames::VERSION_NUMBER, + /* SERIAL_NUMBER */ libjami::Certificate::DetailsNames::SERIAL_NUMBER, + /* ISSUER */ libjami::Certificate::DetailsNames::ISSUER, + /* SUBJECT_KEY_ALGORITHM */ libjami::Certificate::DetailsNames::SUBJECT_KEY_ALGORITHM, + /* CN */ libjami::Certificate::DetailsNames::CN, + /* N */ libjami::Certificate::DetailsNames::N, + /* O */ libjami::Certificate::DetailsNames::O, + /* SIGNATURE_ALGORITHM */ libjami::Certificate::DetailsNames::SIGNATURE_ALGORITHM, + /* MD5_FINGERPRINT */ libjami::Certificate::DetailsNames::MD5_FINGERPRINT, + /* SHA1_FINGERPRINT */ libjami::Certificate::DetailsNames::SHA1_FINGERPRINT, + /* PUBLIC_KEY_ID */ libjami::Certificate::DetailsNames::PUBLIC_KEY_ID, + /* ISSUER_DN */ libjami::Certificate::DetailsNames::ISSUER_DN, + /* NEXT_EXPECTED_UPDATE_DATE */ libjami::Certificate::DetailsNames::NEXT_EXPECTED_UPDATE_DATE, + /* OUTGOING_SERVER */ libjami::Certificate::DetailsNames::OUTGOING_SERVER, + /* IS_CA */ libjami::Certificate::DetailsNames::IS_CA, }}; const EnumClassNames TlsValidator::CheckValuesTypeNames = {{ /* Type Name */ - /* BOOLEAN */ DRing::Certificate::ChecksValuesTypesNames::BOOLEAN, - /* ISO_DATE */ DRing::Certificate::ChecksValuesTypesNames::ISO_DATE, - /* CUSTOM */ DRing::Certificate::ChecksValuesTypesNames::CUSTOM, - /* NUMBER */ DRing::Certificate::ChecksValuesTypesNames::NUMBER, + /* BOOLEAN */ libjami::Certificate::ChecksValuesTypesNames::BOOLEAN, + /* ISO_DATE */ libjami::Certificate::ChecksValuesTypesNames::ISO_DATE, + /* CUSTOM */ libjami::Certificate::ChecksValuesTypesNames::CUSTOM, + /* NUMBER */ libjami::Certificate::ChecksValuesTypesNames::NUMBER, }}; const Matrix2D diff --git a/src/sip/pres_sub_client.cpp b/src/sip/pres_sub_client.cpp index 4fa7dde5a..882abc42f 100644 --- a/src/sip/pres_sub_client.cpp +++ b/src/sip/pres_sub_client.cpp @@ -83,7 +83,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub* sub, pjsip_event* event) if (state == PJSIP_EVSUB_STATE_ACCEPTED) { pres_client->enable(true); - emitSignal(pres->getAccount() + emitSignal(pres->getAccount() ->getAccountID(), std::string(pres_client->getURI()), PJ_TRUE); @@ -96,7 +96,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub* sub, pjsip_event* event) &pres_client->term_reason_, pjsip_evsub_get_termination_reason(sub)); - emitSignal(pres->getAccount() + emitSignal(pres->getAccount() ->getAccountID(), std::string(pres_client->getURI()), PJ_FALSE); @@ -154,7 +154,7 @@ PresSubClient::pres_client_evsub_on_state(pjsip_evsub* sub, pjsip_event* event) * 2) change the support field in the account schema if the pres_sub's server * is the same as the account's server */ - emitSignal( + emitSignal( pres_client->getPresence()->getAccount()->getAccountID(), error, msg); auto account_host = sip_utils::as_view(*pj_gethostname()); diff --git a/src/sip/pres_sub_server.cpp b/src/sip/pres_sub_server.cpp index 33ddcafa3..847c84436 100644 --- a/src/sip/pres_sub_server.cpp +++ b/src/sip/pres_sub_server.cpp @@ -188,7 +188,7 @@ PresSubServer::pres_on_rx_subscribe_request(pjsip_rx_data* rdata) PresSubServer *presSubServer = new PresSubServer(pres, sub, remote, dlg); pjsip_evsub_set_mod_data(sub, pres->getModId(), presSubServer); // Notify the client. - emitSignal(presSubServer->remote_); + emitSignal(presSubServer->remote_); pres->addPresSubServer(presSubServer); /* Capture the value of Expires header. */ diff --git a/src/sip/sipaccount.cpp b/src/sip/sipaccount.cpp index 5277b33fe..159619f5c 100644 --- a/src/sip/sipaccount.cpp +++ b/src/sip/sipaccount.cpp @@ -168,7 +168,7 @@ SIPAccount::~SIPAccount() noexcept std::shared_ptr SIPAccount::newIncomingCall(const std::string& from UNUSED, - const std::vector& mediaList, + const std::vector& mediaList, const std::shared_ptr& transport) { auto call = Manager::instance().callFactory.newSipCall(shared(), @@ -179,7 +179,7 @@ SIPAccount::newIncomingCall(const std::string& from UNUSED, } std::shared_ptr -SIPAccount::newOutgoingCall(std::string_view toUrl, const std::vector& mediaList) +SIPAccount::newOutgoingCall(std::string_view toUrl, const std::vector& mediaList) { std::string to; int family; @@ -313,7 +313,7 @@ SIPAccount::onTransportStateChanged(pjsip_transport_state state, // Notify the client of the new transport state if (currentStatus != transportStatus_) - emitSignal(accountID_, + emitSignal(accountID_, getVolatileAccountDetails()); } @@ -721,7 +721,7 @@ SIPAccount::getVolatileAccountDetails() const a.emplace(Conf::CONFIG_ACCOUNT_REGISTRATION_STATE_CODE, std::to_string(registrationStateDetailed_.first)); a.emplace(Conf::CONFIG_ACCOUNT_REGISTRATION_STATE_DESC, registrationStateDetailed_.second); - a.emplace(DRing::Account::VolatileProperties::InstantMessaging::OFF_CALL, TRUE_STR); + a.emplace(libjami::Account::VolatileProperties::InstantMessaging::OFF_CALL, TRUE_STR); if (presence_) { a.emplace(Conf::CONFIG_PRESENCE_STATUS, presence_->isOnline() ? TRUE_STR : FALSE_STR); @@ -733,17 +733,17 @@ SIPAccount::getVolatileAccountDetails() const auto cipher = pj_ssl_cipher_name(tlsInfos.cipher); if (tlsInfos.cipher and not cipher) JAMI_WARN("Unknown cipher: %d", tlsInfos.cipher); - a.emplace(DRing::TlsTransport::TLS_CIPHER, cipher ? cipher : ""); - a.emplace(DRing::TlsTransport::TLS_PEER_CERT, tlsInfos.peerCert->toString()); + a.emplace(libjami::TlsTransport::TLS_CIPHER, cipher ? cipher : ""); + a.emplace(libjami::TlsTransport::TLS_PEER_CERT, tlsInfos.peerCert->toString()); auto ca = tlsInfos.peerCert->issuer; unsigned n = 0; while (ca) { std::ostringstream name_str; - name_str << DRing::TlsTransport::TLS_PEER_CA_ << n++; + name_str << libjami::TlsTransport::TLS_PEER_CA_ << n++; a.emplace(name_str.str(), ca->toString()); ca = ca->issuer; } - a.emplace(DRing::TlsTransport::TLS_PEER_CA_NUM, std::to_string(n)); + a.emplace(libjami::TlsTransport::TLS_PEER_CA_NUM, std::to_string(n)); } return a; @@ -1570,7 +1570,7 @@ SIPAccount::initContactAddress() address, port); if (not success) - emitSignal(getAccountID()); + emitSignal(getAccountID()); setPublishedAddress({address}); publishedPort_ = port; usePublishedAddressPortInVIA(); @@ -1643,7 +1643,7 @@ SIPAccount::getHostPortFromSTUN(pj_pool_t* pool) addr, port); if (not success) - emitSignal(getAccountID()); + emitSignal(getAccountID()); pjsip_host_port result; pj_strdup2(pool, &result.host, addr.c_str()); result.port = port; @@ -1863,7 +1863,7 @@ SIPAccount::supportPresence(int function, bool enabled) Manager::instance().saveConfig(); // FIXME: bad signal used here, we need a global config changed signal. - emitSignal(); + emitSignal(); } MatchRank diff --git a/src/sip/sipaccount.h b/src/sip/sipaccount.h index 33ff31e6a..3ee3dca85 100644 --- a/src/sip/sipaccount.h +++ b/src/sip/sipaccount.h @@ -426,7 +426,7 @@ public: * @return a shared pointer on the created call. */ std::shared_ptr newOutgoingCall(std::string_view toUrl, - const std::vector& mediaList) override; + const std::vector& mediaList) override; /** * Create incoming SIPCall. @@ -437,7 +437,7 @@ public: */ std::shared_ptr newIncomingCall( const std::string& from, - const std::vector& mediaList, + const std::vector& mediaList, const std::shared_ptr& sipTr = {}) override; void onRegister(pjsip_regc_cbparam* param); diff --git a/src/sip/sipaccountbase.cpp b/src/sip/sipaccountbase.cpp index f383a00da..1e6a79ced 100644 --- a/src/sip/sipaccountbase.cpp +++ b/src/sip/sipaccountbase.cpp @@ -480,9 +480,9 @@ SIPAccountBase::onTextMessage(const std::string& id, std::make_shared(accountID_, from, true, payloads, false)); } #endif - emitSignal(accountID_, from, id, payloads); + emitSignal(accountID_, from, id, payloads); - DRing::Message message; + libjami::Message message; message.from = from; message.payloads = payloads; message.received = std::time(nullptr); @@ -522,7 +522,7 @@ SIPAccountBase::setPublishedAddress(const IpAddr& ip_addr) } } -std::vector +std::vector SIPAccountBase::getLastMessages(const uint64_t& base_timestamp) { std::lock_guard lck(mutexLastMessages_); diff --git a/src/sip/sipaccountbase.h b/src/sip/sipaccountbase.h index bc9a1521e..0896b86e5 100644 --- a/src/sip/sipaccountbase.h +++ b/src/sip/sipaccountbase.h @@ -142,7 +142,7 @@ public: * @return A shared pointer on the created call. */ virtual std::shared_ptr newIncomingCall(const std::string& from, - const std::vector& mediaList, + const std::vector& mediaList, const std::shared_ptr& sipTr = {}) = 0; @@ -282,7 +282,7 @@ public: virtual std::string getUserUri() const = 0; - std::vector getLastMessages(const uint64_t& base_timestamp) override; + std::vector getLastMessages(const uint64_t& base_timestamp) override; // Build the list of medias to be included in the SDP (offer/answer) std::vector createDefaultMediaList(bool addVideo, bool onHold = false); @@ -420,7 +420,7 @@ protected: */ std::mutex mutexLastMessages_; static constexpr size_t MAX_WAITING_MESSAGES_SIZE = 1000; - std::deque lastMessages_; + std::deque lastMessages_; std::string composingUri_; std::chrono::steady_clock::time_point composingTime_ { diff --git a/src/sip/sipcall.cpp b/src/sip/sipcall.cpp index e8bb3ae25..d7df507ba 100644 --- a/src/sip/sipcall.cpp +++ b/src/sip/sipcall.cpp @@ -69,7 +69,7 @@ namespace jami { using sip_utils::CONST_PJ_STR; -using namespace DRing::Call; +using namespace libjami::Call; #ifdef ENABLE_VIDEO static DeviceParams @@ -102,7 +102,7 @@ static const std::vector REUSE_ICE_IN_REINVITE_REQUIRED_VERSION SIPCall::SIPCall(const std::shared_ptr& account, const std::string& callId, Call::CallType type, - const std::vector& mediaList) + const std::vector& mediaList) : Call(account, callId, type) , sdp_(new Sdp(callId)) , enableIce_(account->isIceForMediaEnabled()) @@ -842,7 +842,7 @@ SIPCall::answer() } void -SIPCall::answer(const std::vector& mediaList) +SIPCall::answer(const std::vector& mediaList) { std::lock_guard lk {callMutex_}; auto account = getSIPAccount(); @@ -984,7 +984,7 @@ SIPCall::answer(const std::vector& mediaList) } void -SIPCall::answerMediaChangeRequest(const std::vector& mediaList, bool isRemote) +SIPCall::answerMediaChangeRequest(const std::vector& mediaList, bool isRemote) { std::lock_guard lk {callMutex_}; @@ -2132,7 +2132,7 @@ SIPCall::setupNegotiatedMedia() // TODO. Do we really use this? if (not isSubcall() and peerHolding_ != peer_holding) { peerHolding_ = peer_holding; - emitSignal(getCallId(), peerHolding_); + emitSignal(getCallId(), peerHolding_); } } @@ -2354,7 +2354,7 @@ SIPCall::updateMediaStream(const MediaAttribute& newMediaAttr, size_t streamIdx) rtpStream.rtpSession_->setMuted(mediaAttr->muted_); sendMuteState(mediaAttr->muted_); if (not isSubcall()) - emitSignal(getCallId(), mediaAttr->muted_); + emitSignal(getCallId(), mediaAttr->muted_); return; } @@ -2364,7 +2364,7 @@ SIPCall::updateMediaStream(const MediaAttribute& newMediaAttr, size_t streamIdx) rtpStream.rtpSession_->setMuted(mediaAttr->muted_); if (not isSubcall()) - emitSignal(getCallId(), mediaAttr->muted_); + emitSignal(getCallId(), mediaAttr->muted_); } #endif } @@ -2490,7 +2490,7 @@ SIPCall::isNewIceMediaRequired(const std::vector& mediaAttrList) } bool -SIPCall::requestMediaChange(const std::vector& mediaList) +SIPCall::requestMediaChange(const std::vector& mediaList) { auto mediaAttrList = MediaAttribute::buildMediaAttributesList(mediaList, isSrtpEnabled()); @@ -2647,8 +2647,8 @@ SIPCall::reportMediaNegotiationStatus() { // Notify using the parent Id if it's a subcall. auto callId = isSubcall() ? parent_->getCallId() : getCallId(); - emitSignal( - callId, DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS, currentMediaList()); + emitSignal( + callId, libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS, currentMediaList()); } void @@ -2732,7 +2732,7 @@ SIPCall::onIceNegoSucceed() } bool -SIPCall::checkMediaChangeRequest(const std::vector& remoteMediaList) +SIPCall::checkMediaChangeRequest(const std::vector& remoteMediaList) { // The current media is considered to have changed if one of the // following condtions is true: @@ -2759,7 +2759,7 @@ SIPCall::checkMediaChangeRequest(const std::vector& remoteMedia } void -SIPCall::handleMediaChangeRequest(const std::vector& remoteMediaList) +SIPCall::handleMediaChangeRequest(const std::vector& remoteMediaList) { JAMI_DBG("[call:%s] Handling media change request", getCallId().c_str()); @@ -2784,7 +2784,7 @@ SIPCall::handleMediaChangeRequest(const std::vector& remoteMedi // the local camera will be enabled, unless the video is disabled // in the account settings. - std::vector newMediaList; + std::vector newMediaList; newMediaList.reserve(remoteMediaList.size()); for (auto const& stream : rtpStreams_) { newMediaList.emplace_back(MediaAttribute::toMediaMap(*stream.mediaAttribute_)); @@ -2801,7 +2801,7 @@ SIPCall::handleMediaChangeRequest(const std::vector& remoteMedi } // Report the media change request. - emitSignal(getAccountId(), + emitSignal(getAccountId(), getCallId(), remoteMediaList); } @@ -2975,25 +2975,25 @@ SIPCall::getDetails() const auto details = Call::getDetails(); - details.emplace(DRing::Call::Details::PEER_HOLDING, peerHolding_ ? TRUE_STR : FALSE_STR); + details.emplace(libjami::Call::Details::PEER_HOLDING, peerHolding_ ? TRUE_STR : FALSE_STR); #ifdef ENABLE_VIDEO for (auto const& stream : rtpStreams_) { if (stream.mediaAttribute_->type_ != MediaType::MEDIA_VIDEO) continue; - details.emplace(DRing::Call::Details::VIDEO_SOURCE, stream.mediaAttribute_->sourceUri_); + details.emplace(libjami::Call::Details::VIDEO_SOURCE, stream.mediaAttribute_->sourceUri_); if (auto const& rtpSession = stream.rtpSession_) { if (auto codec = rtpSession->getCodec()) - details.emplace(DRing::Call::Details::VIDEO_CODEC, codec->systemCodecInfo.name); + details.emplace(libjami::Call::Details::VIDEO_CODEC, codec->systemCodecInfo.name); else - details.emplace(DRing::Call::Details::VIDEO_CODEC, ""); + details.emplace(libjami::Call::Details::VIDEO_CODEC, ""); } } #endif #if HAVE_RINGNS if (not peerRegisteredName_.empty()) - details.emplace(DRing::Call::Details::REGISTERED_NAME, peerRegisteredName_); + details.emplace(libjami::Call::Details::REGISTERED_NAME, peerRegisteredName_); #endif #ifdef ENABLE_CLIENT_CERT @@ -3002,24 +3002,24 @@ SIPCall::getDetails() const const auto& tlsInfos = transport_->getTlsInfos(); if (tlsInfos.cipher != PJ_TLS_UNKNOWN_CIPHER) { const auto& cipher = pj_ssl_cipher_name(tlsInfos.cipher); - details.emplace(DRing::TlsTransport::TLS_CIPHER, cipher ? cipher : ""); + details.emplace(libjami::TlsTransport::TLS_CIPHER, cipher ? cipher : ""); } else { - details.emplace(DRing::TlsTransport::TLS_CIPHER, ""); + details.emplace(libjami::TlsTransport::TLS_CIPHER, ""); } if (tlsInfos.peerCert) { - details.emplace(DRing::TlsTransport::TLS_PEER_CERT, tlsInfos.peerCert->toString()); + details.emplace(libjami::TlsTransport::TLS_PEER_CERT, tlsInfos.peerCert->toString()); auto ca = tlsInfos.peerCert->issuer; unsigned n = 0; while (ca) { std::ostringstream name_str; - name_str << DRing::TlsTransport::TLS_PEER_CA_ << n++; + name_str << libjami::TlsTransport::TLS_PEER_CA_ << n++; details.emplace(name_str.str(), ca->toString()); ca = ca->issuer; } - details.emplace(DRing::TlsTransport::TLS_PEER_CA_NUM, std::to_string(n)); + details.emplace(libjami::TlsTransport::TLS_PEER_CA_NUM, std::to_string(n)); } else { - details.emplace(DRing::TlsTransport::TLS_PEER_CERT, ""); - details.emplace(DRing::TlsTransport::TLS_PEER_CA_NUM, ""); + details.emplace(libjami::TlsTransport::TLS_PEER_CERT, ""); + details.emplace(libjami::TlsTransport::TLS_PEER_CA_NUM, ""); } } #endif @@ -3483,10 +3483,10 @@ SIPCall::peerRecording(bool state) const std::string& id = conference ? conference->getConfId() : getCallId(); if (state) { JAMI_WARN("[call:%s] Peer is recording", getCallId().c_str()); - emitSignal(id, getPeerNumber(), true); + emitSignal(id, getPeerNumber(), true); } else { JAMI_WARN("Peer stopped recording"); - emitSignal(id, getPeerNumber(), false); + emitSignal(id, getPeerNumber(), false); } peerRecording_ = state; if (auto conf = conf_.lock()) diff --git a/src/sip/sipcall.h b/src/sip/sipcall.h index a281c35ac..182596e2d 100644 --- a/src/sip/sipcall.h +++ b/src/sip/sipcall.h @@ -108,7 +108,7 @@ public: SIPCall(const std::shared_ptr& account, const std::string& id, Call::CallType type, - const std::vector& mediaList); + const std::vector& mediaList); // Inherited from Call class LinkType getLinkType() const override { return LINK_TYPE; } @@ -119,10 +119,10 @@ private: public: void answer() override; - void answer(const std::vector& mediaList) override; - bool checkMediaChangeRequest(const std::vector& remoteMediaList) override; - void handleMediaChangeRequest(const std::vector& remoteMediaList) override; - void answerMediaChangeRequest(const std::vector& mediaList, + void answer(const std::vector& mediaList) override; + bool checkMediaChangeRequest(const std::vector& remoteMediaList) override; + void handleMediaChangeRequest(const std::vector& remoteMediaList) override; + void answerMediaChangeRequest(const std::vector& mediaList, bool isRemote = false) override; void hangup(int reason) override; void refuse() override; @@ -133,8 +133,8 @@ public: void switchInput(const std::string& resource = {}) override; void peerHungup() override; void carryingDTMFdigits(char code) override; - bool requestMediaChange(const std::vector& mediaList) override; - std::vector currentMediaList() const override; + bool requestMediaChange(const std::vector& mediaList) override; + std::vector currentMediaList() const override; void sendTextMessage(const std::map& messages, const std::string& from) override; void removeCall() override; diff --git a/src/sip/sippresence.cpp b/src/sip/sippresence.cpp index c52e24176..370982e42 100644 --- a/src/sip/sippresence.cpp +++ b/src/sip/sippresence.cpp @@ -196,7 +196,7 @@ SIPPresence::reportPresSubClientNotification(std::string_view uri, pjsip_pres_st note_ = note; } // report status to client signal - emitSignal(acc_ID, + emitSignal(acc_ID, std::string(uri), status->info[0].basic_open, note); @@ -371,7 +371,7 @@ SIPPresence::publish_cb(struct pjsip_publishc_cbparam* param) char errmsg[PJ_ERR_MSG_SIZE]; pj_strerror(param->status, errmsg, sizeof(errmsg)); JAMI_ERR("Client (PUBLISH) failed, status=%d, msg=%s", param->status, errmsg); - emitSignal(pres->getAccount()->getAccountID(), + emitSignal(pres->getAccount()->getAccountID(), error, errmsg); @@ -385,7 +385,7 @@ SIPPresence::publish_cb(struct pjsip_publishc_cbparam* param) || (param->code == PJSIP_SC_NOT_IMPLEMENTED)) { // 489 or 501 JAMI_WARN("Client (PUBLISH) failed (%s)", error.c_str()); - emitSignal(pres->getAccount()->getAccountID(), + emitSignal(pres->getAccount()->getAccountID(), error, "Publish not supported."); diff --git a/src/sip/sipvoiplink.cpp b/src/sip/sipvoiplink.cpp index fc89b3e1f..8813a5320 100644 --- a/src/sip/sipvoiplink.cpp +++ b/src/sip/sipvoiplink.cpp @@ -317,7 +317,7 @@ transaction_request_cb(pjsip_rx_data* rdata) // According to rfc3842 // urgent messages are optional if (ret >= 2) - emitSignal(account->getAccountID(), + emitSignal(account->getAccountID(), newCount, oldCount, urgentCount); diff --git a/src/smartools.cpp b/src/smartools.cpp index d700b9964..e8307deb3 100644 --- a/src/smartools.cpp +++ b/src/smartools.cpp @@ -41,7 +41,7 @@ void Smartools::sendInfo() { std::lock_guard lk(mutexInfo_); - emitSignal(information_); + emitSignal(information_); information_.clear(); } diff --git a/test/agent/src/bindings/account.h b/test/agent/src/bindings/account.h index e0c8bf25e..783e0af18 100644 --- a/test/agent/src/bindings/account.h +++ b/test/agent/src/bindings/account.h @@ -32,7 +32,7 @@ static SCM set_details_binding(SCM accountID_str, SCM details_alist) { LOG_BINDING(); - DRing::setAccountDetails(from_guile(accountID_str), + libjami::setAccountDetails(from_guile(accountID_str), from_guile(details_alist)); return SCM_UNDEFINED; } @@ -41,14 +41,14 @@ static SCM get_details_binding(SCM accountID_str) { LOG_BINDING(); - return to_guile(DRing::getAccountDetails(from_guile(accountID_str))); + return to_guile(libjami::getAccountDetails(from_guile(accountID_str))); } static SCM send_register_binding(SCM accountID_str, SCM enable_boolean) { LOG_BINDING(); - DRing::sendRegister(from_guile(accountID_str), + libjami::sendRegister(from_guile(accountID_str), from_guile(enable_boolean)); return SCM_UNDEFINED; @@ -59,11 +59,11 @@ static SCM export_to_file_binding(SCM accountID_str, SCM path_str, SCM passwd_st LOG_BINDING(); if (SCM_UNBNDP(passwd_str_optional)) { - return to_guile(DRing::exportToFile(from_guile(accountID_str), + return to_guile(libjami::exportToFile(from_guile(accountID_str), from_guile(path_str))); } - return to_guile(DRing::exportToFile(from_guile(accountID_str), + return to_guile(libjami::exportToFile(from_guile(accountID_str), from_guile(path_str), from_guile(passwd_str_optional))); } @@ -74,10 +74,10 @@ add_account_binding(SCM details_alist, SCM accountID_str_optional) LOG_BINDING(); if (SCM_UNBNDP(accountID_str_optional)) { - return to_guile(DRing::addAccount(from_guile(details_alist))); + return to_guile(libjami::addAccount(from_guile(details_alist))); } - return to_guile(DRing::addAccount(from_guile(details_alist), + return to_guile(libjami::addAccount(from_guile(details_alist), from_guile(accountID_str_optional))); } @@ -86,7 +86,7 @@ accept_trust_request_binding(SCM accountID_str, SCM from_uri_str) { LOG_BINDING(); - return to_guile(DRing::acceptTrustRequest(from_guile(accountID_str), + return to_guile(libjami::acceptTrustRequest(from_guile(accountID_str), from_guile(from_uri_str))); } @@ -99,7 +99,7 @@ send_trust_request_binding(SCM accountID_str, SCM to_uri_str, SCM payload_vector payload_vector_uint8_optional = scm_c_make_vector(0, SCM_UNDEFINED); } - DRing::sendTrustRequest(from_guile(accountID_str), + libjami::sendTrustRequest(from_guile(accountID_str), from_guile(to_uri_str), from_guile(payload_vector_uint8_optional)); return SCM_UNDEFINED; @@ -110,7 +110,7 @@ get_contacts_binding(SCM accountID_str) { LOG_BINDING(); - return to_guile(DRing::getContacts(from_guile(accountID_str))); + return to_guile(libjami::getContacts(from_guile(accountID_str))); } static SCM @@ -118,7 +118,7 @@ subscribe_buddy_binding(SCM accountID_str, SCM peer_uri_str, SCM flag_bool) { LOG_BINDING(); - DRing::subscribeBuddy(from_guile(accountID_str), + libjami::subscribeBuddy(from_guile(accountID_str), from_guile(peer_uri_str), from_guile(flag_bool)); @@ -130,7 +130,7 @@ add_contact_binding(SCM accountID_str, SCM uri_str) { LOG_BINDING(); - DRing::addContact(from_guile(accountID_str), + libjami::addContact(from_guile(accountID_str), from_guile(uri_str)); return SCM_UNDEFINED; @@ -141,7 +141,7 @@ remove_contact_binding(SCM accountID_str, SCM uri_str, SCM ban_optional_bool) { LOG_BINDING(); - DRing::removeContact(from_guile(accountID_str), + libjami::removeContact(from_guile(accountID_str), from_guile(uri_str), from_guile(ban_optional_bool)); diff --git a/test/agent/src/bindings/call.h b/test/agent/src/bindings/call.h index e4cb48efc..aa2a7e5f5 100644 --- a/test/agent/src/bindings/call.h +++ b/test/agent/src/bindings/call.h @@ -38,7 +38,7 @@ place_call_with_media_binding(SCM accountID_str, call_media_vector_alist_optional = scm_c_make_vector(0, SCM_UNDEFINED); } - return to_guile(DRing::placeCallWithMedia(from_guile(accountID_str), + return to_guile(libjami::placeCallWithMedia(from_guile(accountID_str), from_guile(contact_str), from_guile(call_media_vector_alist_optional))); } @@ -48,7 +48,7 @@ hang_up_binding(SCM accountID_str, SCM callID_str) { LOG_BINDING(); - return to_guile(DRing::hangUp(from_guile(accountID_str), from_guile(callID_str))); + return to_guile(libjami::hangUp(from_guile(accountID_str), from_guile(callID_str))); } static SCM @@ -57,10 +57,10 @@ accept_binding(SCM accountID_str, SCM callID_str, SCM call_media_vector_alist_op LOG_BINDING(); if (SCM_UNBNDP(call_media_vector_alist_optional)) { - return to_guile(DRing::accept(from_guile(accountID_str), from_guile(callID_str))); + return to_guile(libjami::accept(from_guile(accountID_str), from_guile(callID_str))); } - return to_guile(DRing::acceptWithMedia(from_guile(accountID_str), + return to_guile(libjami::acceptWithMedia(from_guile(accountID_str), from_guile(callID_str), from_guile(call_media_vector_alist_optional))); } @@ -70,7 +70,7 @@ refuse_binding(SCM accountID_str, SCM callID_str) { LOG_BINDING(); - return to_guile(DRing::refuse(from_guile(accountID_str), from_guile(callID_str))); + return to_guile(libjami::refuse(from_guile(accountID_str), from_guile(callID_str))); } static SCM @@ -78,7 +78,7 @@ hold_binding(SCM accountID_str, SCM callID_str) { LOG_BINDING(); - return to_guile(DRing::hold(from_guile(accountID_str), from_guile(callID_str))); + return to_guile(libjami::hold(from_guile(accountID_str), from_guile(callID_str))); } static SCM @@ -86,7 +86,7 @@ unhold_binding(SCM accountID_str, SCM callID_str) { LOG_BINDING(); - return to_guile(DRing::unhold(from_guile(accountID_str), from_guile(callID_str))); + return to_guile(libjami::unhold(from_guile(accountID_str), from_guile(callID_str))); } static void diff --git a/test/agent/src/bindings/conversation.h b/test/agent/src/bindings/conversation.h index 33fcc6ace..25cd45c88 100644 --- a/test/agent/src/bindings/conversation.h +++ b/test/agent/src/bindings/conversation.h @@ -31,7 +31,7 @@ get_conversations_binding(SCM accountID_str) { LOG_BINDING(); - return to_guile(DRing::getConversations(from_guile(accountID_str))); + return to_guile(libjami::getConversations(from_guile(accountID_str))); } static SCM @@ -39,7 +39,7 @@ get_conversation_members_binding(SCM accountID_str, SCM conversationID_str) { LOG_BINDING(); - return to_guile(DRing::getConversationMembers(from_guile(accountID_str), + return to_guile(libjami::getConversationMembers(from_guile(accountID_str), from_guile(conversationID_str))); } @@ -48,7 +48,7 @@ accept_conversation_binding(SCM accountID_str, SCM conversationID_str) { LOG_BINDING(); - DRing::acceptConversationRequest(from_guile(accountID_str), + libjami::acceptConversationRequest(from_guile(accountID_str), from_guile(conversationID_str)); return SCM_UNDEFINED; @@ -61,13 +61,13 @@ send_message_binding(SCM accountID_str, SCM conversationID_str, SCM message_str, LOG_BINDING(); if (SCM_UNBNDP(parent_str_optional)) { - DRing::sendMessage(from_guile(accountID_str), + libjami::sendMessage(from_guile(accountID_str), from_guile(conversationID_str), from_guile(message_str), ""); } else { - DRing::sendMessage(from_guile(accountID_str), + libjami::sendMessage(from_guile(accountID_str), from_guile(conversationID_str), from_guile(message_str), from_guile(parent_str_optional)); diff --git a/test/agent/src/bindings/jami.h b/test/agent/src/bindings/jami.h index 89e28f1d3..0c1d77c0f 100644 --- a/test/agent/src/bindings/jami.h +++ b/test/agent/src/bindings/jami.h @@ -30,14 +30,14 @@ static SCM init_binding(SCM flags) unsigned int flags_cast = from_guile(flags); - return to_guile(DRing::init(static_cast(flags_cast))); + return to_guile(libjami::init(static_cast(flags_cast))); } static SCM fini_binding() { LOG_BINDING(); - DRing::fini(); + libjami::fini(); return SCM_UNDEFINED; } @@ -46,14 +46,14 @@ static SCM initialized_binding() { LOG_BINDING(); - return to_guile(DRing::initialized()); + return to_guile(libjami::initialized()); } static SCM logging_binding(SCM whom, SCM action) { LOG_BINDING(); - DRing::logging(from_guile(whom), from_guile(action)); + libjami::logging(from_guile(whom), from_guile(action)); return SCM_UNDEFINED; } @@ -62,21 +62,21 @@ static SCM platform_binding() { LOG_BINDING(); - return to_guile(DRing::platform()); + return to_guile(libjami::platform()); } static SCM start_binding(SCM config_file) { LOG_BINDING(); - return to_guile(DRing::start(from_guile(config_file))); + return to_guile(libjami::start(from_guile(config_file))); } static SCM version_binding() { LOG_BINDING(); - return to_guile(DRing::version()); + return to_guile(libjami::version()); } static void diff --git a/test/agent/src/bindings/signal.cpp b/test/agent/src/bindings/signal.cpp index 8b509ec46..7a0ef07d5 100644 --- a/test/agent/src/bindings/signal.cpp +++ b/test/agent/src/bindings/signal.cpp @@ -150,7 +150,7 @@ on_signal_binding(SCM signal_sym, SCM handler_proc) template void -add_handler(std::map>& handlers, +add_handler(std::map>& handlers, const char* name) { static Handler handler(name); @@ -159,7 +159,7 @@ add_handler(std::map>& handler.execute(args...); }; - handlers.insert(DRing::exportable_callback(std::move(fn))); + handlers.insert(libjami::exportable_callback(std::move(fn))); } void @@ -167,277 +167,277 @@ install_signal_primitives(void*) { define_primitive("on-signal", 2, 0, 0, (void*) on_signal_binding); - std::map> handlers; + std::map> handlers; - add_handler(handlers, "state-changed"); - add_handler(handlers, "transfer-failed"); + add_handler(handlers, "transfer-failed"); - add_handler(handlers, "transfer-succeeded"); + add_handler(handlers, "transfer-succeeded"); - add_handler(handlers, "record-playback-stopped"); - add_handler( + add_handler( handlers, "voice-mail-notify"); - add_handler&>(handlers, "incoming-message"); - add_handler(handlers, "incoming-call"); - add_handler>(handlers, "incoming-call/media"); + const std::vector>(handlers, "incoming-call/media"); - add_handler>&>(handlers, "media-change-requested"); - add_handler( + add_handler( handlers, "record-playback-filepath"); - add_handler( + add_handler( handlers, "conference-created"); - add_handler(handlers, "conference-changed"); - add_handler( + add_handler( handlers, "update-playback-scale"); - add_handler( + add_handler( handlers, "conference-removed"); - add_handler( + add_handler( handlers, "recording-state-changed"); - add_handler&>(handlers, "rtcp-report-received"); - add_handler(handlers, "peer-hold"); + add_handler(handlers, "peer-hold"); - add_handler(handlers, "video-muted"); + add_handler(handlers, "video-muted"); - add_handler(handlers, "audio-muted"); + add_handler(handlers, "audio-muted"); - add_handler&>(handlers, "smart-info"); - add_handler(handlers, + add_handler(handlers, "connection-update"); - add_handler>&>(handlers, "conference-infos-updated"); - add_handler(handlers, "remote-recording-changed"); - add_handler>&>(handlers, "media-negotiation-status"); /* Configuration */ - add_handler( + add_handler( handlers, "volume-changed"); - add_handler(handlers, "configuration-error"); + add_handler(handlers, "configuration-error"); - add_handler(handlers, "accounts-changed"); + add_handler(handlers, "accounts-changed"); - add_handler&>(handlers, "account-details-changed"); - add_handler(handlers, "stun-status-failed"); - add_handler(handlers, "registration-state-changed"); - add_handler&>(handlers, "volatile-details-changed"); - add_handler&>(handlers, "incoming-account-message"); - add_handler(handlers, "account-message-status-changed"); - add_handler(handlers, "profile-received"); - add_handler(handlers, "composing-status-changed"); - add_handler&, time_t>(handlers, "incoming-trust-request"); - add_handler(handlers, "contact-added"); - add_handler(handlers, "contact-removed"); - add_handler(handlers, "export-on-ring-ended"); - add_handler(handlers, "name-registration-ended"); - add_handler&>(handlers, "known-devices-changed"); - add_handler(handlers, "registered-name-found"); - add_handler>&>(handlers, "user-search-ended"); - add_handler(handlers, "certificate-pinned"); - add_handler&>(handlers, "certificate-path-pinned"); - add_handler(handlers, "certificate-expired"); - add_handler(handlers, "certificate-state-changed"); - add_handler(handlers, "media-parameters-changed"); - add_handler( + add_handler( handlers, "migration-ended"); - add_handler(handlers, "device-revocation-ended"); - add_handler(handlers, "account-profile-received"); #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) - add_handler*>(handlers, "get-hardware-audio-format"); #endif #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) || defined(RING_UWP) - add_handler*>(handlers, "get-app-data-path"); - add_handler*>(handlers, "get-device-name"); #endif - add_handler(handlers, "hardware-decoding-changed"); - add_handler(handlers, "hardware-encoding-changed"); - add_handler(handlers, + add_handler(handlers, "message-send"); /* Presence */ - add_handler(handlers, "new-server-subscription-request"); - add_handler(handlers, "server-error"); - add_handler(handlers, "new-buddy-notification"); - add_handler(handlers, "nearby-peer-notification"); - add_handler(handlers, "subscription-state-changed"); /* Audio */ - add_handler(handlers, "audio-device-event"); + add_handler(handlers, "audio-device-event"); - add_handler(handlers, "audio-meter"); + add_handler(handlers, "audio-meter"); /* DataTransfer */ - add_handler>(handlers, "media-file-opened"); /* Video */ - add_handler(handlers, "device-event"); + add_handler(handlers, "device-event"); - add_handler(handlers, "video-decoding-started"); - add_handler( + add_handler( handlers, "video-decoding-stopped"); #ifdef __ANDROID__ - add_handler*, std::vector*, std::vector*>(handlers, "video-get-camera-info"); - add_handler(handlers, "video-set-parameters"); - add_handler(handlers, "video-request-key-frame"); + add_handler(handlers, "video-request-key-frame"); - add_handler(handlers, + add_handler(handlers, "video-set-bitrate"); #endif - add_handler(handlers, + add_handler(handlers, "video-start-capture"); - add_handler(handlers, "video-stop-capture"); + add_handler(handlers, "video-stop-capture"); - add_handler(handlers, "video-device-added"); + add_handler(handlers, "video-device-added"); - add_handler(handlers, "video-parameters-changed"); #endif /* Conversation */ - add_handler>>(handlers, "conversation-loaded"); - add_handler>>(handlers, "messages-found"); - add_handler>(handlers, "message-received"); - add_handler>(handlers, "conversation-request-received"); - add_handler(handlers, "conversation-request-declined"); - add_handler( + add_handler( handlers, "conversation-ready"); - add_handler(handlers, "conversation-removed"); - add_handler(handlers, "conversation-member-event"); - add_handler(handlers, "conversation-error"); - add_handler>(handlers, "conversation-preferences-updated"); - DRing::registerSignalHandlers(handlers); + libjami::registerSignalHandlers(handlers); } diff --git a/test/agent/src/main.cpp b/test/agent/src/main.cpp index bfa74e0f5..477addbc5 100644 --- a/test/agent/src/main.cpp +++ b/test/agent/src/main.cpp @@ -25,7 +25,7 @@ #include extern "C" { -DRING_PUBLIC void bootstrap(); +LIBJAMI_PUBLIC void bootstrap(); } void diff --git a/test/fuzzing/lib/utils.cpp b/test/fuzzing/lib/utils.cpp index 0dd8f9797..631177054 100644 --- a/test/fuzzing/lib/utils.cpp +++ b/test/fuzzing/lib/utils.cpp @@ -35,7 +35,7 @@ void wait_for_announcement_of(const std::vector accountIDs, std::chrono::seconds timeout) { - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; @@ -45,7 +45,7 @@ wait_for_announcement_of(const std::vector accountIDs, std::chrono: size_t to_be_announced = accountIDs.size(); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [=, accountIDs = std::move(accountIDs)](const std::string& accountID, const std::map& details) { @@ -56,7 +56,7 @@ wait_for_announcement_of(const std::vector accountIDs, std::chrono: try { if ("true" - != details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED)) { + != details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED)) { continue; } } catch (const std::out_of_range&) { @@ -70,7 +70,7 @@ wait_for_announcement_of(const std::vector accountIDs, std::chrono: JAMI_DBG("Waiting for %zu account to be announced...", to_be_announced); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); assert(cv->wait_for(lk, timeout, [&] { for (const auto& rdy : *accountsReady) { @@ -82,7 +82,7 @@ wait_for_announcement_of(const std::vector accountIDs, std::chrono: return true; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_DBG("%zu account announced!", to_be_announced); } @@ -96,7 +96,7 @@ wait_for_announcement_of(const std::string& accountId, std::chrono::seconds time void wait_for_removal_of(const std::vector accounts, std::chrono::seconds timeout) { - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; @@ -112,7 +112,7 @@ wait_for_removal_of(const std::vector accounts, std::chrono::second size_t target = current - accounts.size(); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=, accounts = std::move(accounts)]() { if (jami::Manager::instance().getAccountList().size() <= target) { *accountsRemoved = true; @@ -120,8 +120,8 @@ wait_for_removal_of(const std::vector accounts, std::chrono::second } })); - DRing::unregisterSignalHandlers(); - DRing::registerSignalHandlers(confHandlers); + libjami::unregisterSignalHandlers(); + libjami::registerSignalHandlers(confHandlers); for (const auto& account : accounts) { jami::Manager::instance().removeAccount(account, true); @@ -129,7 +129,7 @@ wait_for_removal_of(const std::vector accounts, std::chrono::second assert(cv->wait_for(lk, timeout, [&] { return accountsRemoved->load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -142,7 +142,7 @@ std::map load_actors(const std::string& from_yaml) { std::map actors {}; - std::map default_details = DRing::getAccountTemplate("RING"); + std::map default_details = libjami::getAccountTemplate("RING"); std::ifstream file = jami::fileutils::ifstream(from_yaml); diff --git a/test/fuzzing/scenarios/classic-alice-and-bob.h b/test/fuzzing/scenarios/classic-alice-and-bob.h index 893621ac9..6895cf449 100644 --- a/test/fuzzing/scenarios/classic-alice-and-bob.h +++ b/test/fuzzing/scenarios/classic-alice-and-bob.h @@ -30,10 +30,10 @@ int main(void) { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not jami::Manager::instance().initialized) { - assert(DRing::start("dring-sample.yml")); + assert(libjami::start("dring-sample.yml")); } auto actors = load_actors_and_wait_for_announcement("actors/alice-bob.yml"); @@ -47,19 +47,19 @@ int main(void) auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; + std::map> confHandlers; std::atomic_bool callReceived {false}; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string&) { callReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); auto call = aliceAccount->newOutgoingCall(bobUri); @@ -69,7 +69,7 @@ int main(void) wait_for_removal_of({alice, bob}); - DRing::fini(); + libjami::fini(); return 0; } diff --git a/test/sip/sip.cpp b/test/sip/sip.cpp index 9de835da1..3cbc786e8 100644 --- a/test/sip/sip.cpp +++ b/test/sip/sip.cpp @@ -27,8 +27,8 @@ void init_daemon() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); - DRing::start("test/unitTest/jami-sample.yml"); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); + libjami::start("test/unitTest/jami-sample.yml"); } int main() @@ -54,7 +54,7 @@ int main() ret = 1; } - DRing::fini(); + libjami::fini(); return ret; } diff --git a/test/unitTest/account_archive/account_archive.cpp b/test/unitTest/account_archive/account_archive.cpp index fae8ec62c..e8a11fdc5 100644 --- a/test/unitTest/account_archive/account_archive.cpp +++ b/test/unitTest/account_archive/account_archive.cpp @@ -43,7 +43,7 @@ using namespace std::string_literals; using namespace std::literals::chrono_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -54,11 +54,11 @@ public: AccountArchiveTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("dring-sample.yml")); + CPPUNIT_ASSERT(libjami::start("dring-sample.yml")); } - ~AccountArchiveTest() { DRing::fini(); } + ~AccountArchiveTest() { libjami::fini(); } static std::string name() { return "AccountArchive"; } void setUp(); void tearDown(); @@ -113,7 +113,7 @@ AccountArchiveTest::testExportImportNoPassword() CPPUNIT_ASSERT(aliceAccount->exportArchive("test.gz")); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PATH] = "test.gz"; auto accountId = jami::Manager::instance().addAccount(details); @@ -133,7 +133,7 @@ AccountArchiveTest::testExportImportNoPasswordDoubleGunzip() auto dat = fileutils::loadFile("test.gz"); archiver::compressGzip(dat, "test.gz"); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PATH] = "test.gz"; auto accountId = jami::Manager::instance().addAccount(details); @@ -151,7 +151,7 @@ AccountArchiveTest::testExportImportPassword() CPPUNIT_ASSERT(bobAccount->exportArchive("test.gz", "test")); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PATH] = "test.gz"; details[ConfProperties::ARCHIVE_PASSWORD] = "test"; @@ -172,7 +172,7 @@ AccountArchiveTest::testExportImportPasswordDoubleGunzip() auto dat = fileutils::loadFile("test.gz"); archiver::compressGzip(dat, "test.gz"); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PATH] = "test.gz"; details[ConfProperties::ARCHIVE_PASSWORD] = "test"; @@ -190,21 +190,21 @@ AccountArchiveTest::testExportDht() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::string pin; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, int status, const std::string& p) { if (accountId == bobId && status == 0) pin = p; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - CPPUNIT_ASSERT(DRing::exportOnRing(bobId, "test")); + libjami::registerSignalHandlers(confHandlers); + CPPUNIT_ASSERT(libjami::exportOnRing(bobId, "test")); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !pin.empty(); })); auto bobAccount = Manager::instance().getAccount(bobId); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PIN] = pin; details[ConfProperties::ARCHIVE_PASSWORD] = "test"; @@ -220,16 +220,16 @@ AccountArchiveTest::testExportDhtWrongPassword() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; int status; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, int s, const std::string&) { if (accountId == bobId) status = s; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - CPPUNIT_ASSERT(DRing::exportOnRing(bobId, "wrong")); + libjami::registerSignalHandlers(confHandlers); + CPPUNIT_ASSERT(libjami::exportOnRing(bobId, "wrong")); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return status == 1; })); } @@ -237,13 +237,13 @@ void AccountArchiveTest::testChangePassword() { // Test wrong password, should fail - CPPUNIT_ASSERT(!DRing::changeAccountPassword(aliceId, "wrong", "new")); + CPPUNIT_ASSERT(!libjami::changeAccountPassword(aliceId, "wrong", "new")); // Test correct password, should succeed - CPPUNIT_ASSERT(DRing::changeAccountPassword(aliceId, "", "new")); + CPPUNIT_ASSERT(libjami::changeAccountPassword(aliceId, "", "new")); // Now it should fail - CPPUNIT_ASSERT(!DRing::changeAccountPassword(aliceId, "", "new")); + CPPUNIT_ASSERT(!libjami::changeAccountPassword(aliceId, "", "new")); // Remove password again (should succeed) - CPPUNIT_ASSERT(DRing::changeAccountPassword(aliceId, "new", "")); + CPPUNIT_ASSERT(libjami::changeAccountPassword(aliceId, "new", "")); } } // namespace test diff --git a/test/unitTest/account_archive/migration.cpp b/test/unitTest/account_archive/migration.cpp index d1a285d79..41af5d878 100644 --- a/test/unitTest/account_archive/migration.cpp +++ b/test/unitTest/account_archive/migration.cpp @@ -37,7 +37,7 @@ using namespace std::string_literals; using namespace std::literals::chrono_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -48,11 +48,11 @@ public: MigrationTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("dring-sample.yml")); + CPPUNIT_ASSERT(libjami::start("dring-sample.yml")); } - ~MigrationTest() { DRing::fini(); } + ~MigrationTest() { libjami::fini(); } static std::string name() { return "AccountArchive"; } void setUp(); void tearDown(); @@ -132,16 +132,16 @@ MigrationTest::testLoadExpiredAccount() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto aliceMigrated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& state) { if (accountId == aliceId && state == "SUCCESS") { aliceMigrated = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Check migration is triggered and expiration updated aliceAccount->forceReloadAccount(); @@ -169,12 +169,12 @@ MigrationTest::testMigrationAfterRevokation() std::condition_variable cv; // Add second device for Bob - std::map> confHandlers; + std::map> confHandlers; auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -185,14 +185,14 @@ MigrationTest::testMigrationAfterRevokation() auto deviceRevoked = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string&, int status) { if (accountId == bobId && status == 0) deviceRevoked = true; cv.notify_one(); })); auto bobMigrated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& state) { if (accountId == bob2Id && state == "SUCCESS") { bobMigrated = true; @@ -200,13 +200,13 @@ MigrationTest::testMigrationAfterRevokation() cv.notify_one(); })); auto knownChanged = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, auto devices) { if (accountId == bobId && devices.size() == 2) knownChanged = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); bob2Id = Manager::instance().addAccount(details); auto bob2Account = Manager::instance().getAccount(bob2Id); @@ -236,9 +236,9 @@ MigrationTest::testExpiredDeviceInSwarm() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -251,7 +251,7 @@ MigrationTest::testExpiredDeviceInSwarm() })); bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -259,7 +259,7 @@ MigrationTest::testExpiredDeviceInSwarm() cv.notify_one(); })); bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -267,7 +267,7 @@ MigrationTest::testExpiredDeviceInSwarm() } })); auto aliceMigrated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& state) { if (accountId == aliceId && state == "SUCCESS") { aliceMigrated = true; @@ -276,20 +276,20 @@ MigrationTest::testExpiredDeviceInSwarm() })); bool aliceStopped = false, aliceAnnounced = false, aliceRegistered = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (daemonStatus == "UNREGISTERED") aliceStopped = true; else if (daemonStatus == "REGISTERED") aliceRegistered = true; - auto announced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto announced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (announced == "true") aliceAnnounced = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); CPPUNIT_ASSERT(aliceAccount->setValidity("", {}, 90)); auto now = std::chrono::system_clock::now(); @@ -308,13 +308,13 @@ MigrationTest::testExpiredDeviceInSwarm() CPPUNIT_ASSERT(aliceAccount->currentDeviceId() == aliceDevice); // Create conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return conversationReady; })); // Assert that repository exists @@ -325,7 +325,7 @@ MigrationTest::testExpiredDeviceInSwarm() cv.wait_for(lk, 20s, [&]() { return messageAliceReceived == 1; }); messageBobReceived = 0; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return messageBobReceived == 1; })); // Wait for certificate to expire @@ -345,10 +345,10 @@ MigrationTest::testExpiredDeviceInSwarm() // Resend a new message messageBobReceived = 0; - DRing::sendMessage(aliceId, convId, "hi again"s, ""); + libjami::sendMessage(aliceId, convId, "hi again"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return messageBobReceived == 1; })); messageAliceReceived = 0; - DRing::sendMessage(bobId, convId, "hi!"s, ""); + libjami::sendMessage(bobId, convId, "hi!"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return messageAliceReceived == 1; })); // check that certificate in conversation is updated diff --git a/test/unitTest/account_factory/testAccount_factory.cpp b/test/unitTest/account_factory/testAccount_factory.cpp index 358c5073e..dcec3b2db 100644 --- a/test/unitTest/account_factory/testAccount_factory.cpp +++ b/test/unitTest/account_factory/testAccount_factory.cpp @@ -57,8 +57,8 @@ void Account_factoryTest::setUp() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); accountFactory.reset(new AccountFactory); } @@ -67,7 +67,7 @@ void Account_factoryTest::tearDown() { // Stop daemon - DRing::fini(); + libjami::fini(); } @@ -78,7 +78,7 @@ Account_factoryTest::testAddRemoveSIPAccount() CPPUNIT_ASSERT(accountFactory->empty()); CPPUNIT_ASSERT(accountFactory->accountCount()==0); - accountFactory->createAccount(DRing::Account::ProtocolNames::SIP, SIP_ID); + accountFactory->createAccount(libjami::Account::ProtocolNames::SIP, SIP_ID); CPPUNIT_ASSERT(accountFactory->hasAccount(SIP_ID)); CPPUNIT_ASSERT(!accountFactory->hasAccount(RING_ID)); @@ -98,7 +98,7 @@ Account_factoryTest::testAddRemoveRINGAccount() CPPUNIT_ASSERT(accountFactory->empty()); CPPUNIT_ASSERT(accountFactory->accountCount()==0); - accountFactory->createAccount(DRing::Account::ProtocolNames::RING, RING_ID); + accountFactory->createAccount(libjami::Account::ProtocolNames::RING, RING_ID); CPPUNIT_ASSERT(accountFactory->hasAccount(RING_ID)); CPPUNIT_ASSERT(!accountFactory->hasAccount(SIP_ID)); @@ -121,7 +121,7 @@ Account_factoryTest::testClear() const int nbrAccount = 5; for(int i = 0; i < nbrAccount ; ++i) { - accountFactory->createAccount(DRing::Account::ProtocolNames::RING, RING_ID+std::to_string(i)); + accountFactory->createAccount(libjami::Account::ProtocolNames::RING, RING_ID+std::to_string(i)); } CPPUNIT_ASSERT(accountFactory->accountCount()==nbrAccount); diff --git a/test/unitTest/call/call.cpp b/test/unitTest/call/call.cpp index ed209d012..f282a5af5 100644 --- a/test/unitTest/call/call.cpp +++ b/test/unitTest/call/call.cpp @@ -35,7 +35,7 @@ #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -46,11 +46,11 @@ public: CallTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~CallTest() { DRing::fini(); } + ~CallTest() { libjami::fini(); } static std::string name() { return "Call"; } void setUp(); void tearDown(); @@ -109,11 +109,11 @@ CallTest::testCall() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::atomic_bool callReceived {false}; std::atomic callStopped {0}; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string&, @@ -121,7 +121,7 @@ CallTest::testCall() callReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string& state, signed) { if (state == "OVER") { callStopped += 1; @@ -129,10 +129,10 @@ CallTest::testCall() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); JAMI_INFO("Start call between alice and Bob"); - auto call = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto call = libjami::placeCallWithMedia(aliceId, bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&] { return callReceived.load(); })); @@ -154,11 +154,11 @@ CallTest::testCachedCall() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::atomic_bool callReceived {false}, successfullyConnected {false}; std::atomic callStopped {0}; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string&, @@ -166,7 +166,7 @@ CallTest::testCachedCall() callReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string& state, signed) { if (state == "OVER") { callStopped += 1; @@ -174,7 +174,7 @@ CallTest::testCachedCall() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); JAMI_INFO("Connect Alice's device and Bob's device"); aliceAccount->connectionManager() @@ -190,7 +190,7 @@ CallTest::testCachedCall() cv.wait_for(lk, std::chrono::seconds(30), [&] { return successfullyConnected.load(); })); JAMI_INFO("Start call between alice and Bob"); - auto call = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto call = libjami::placeCallWithMedia(aliceId, bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&] { return callReceived.load(); })); callStopped = 0; @@ -212,20 +212,20 @@ CallTest::testStopSearching() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::atomic_bool callStopped {false}; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string& state, signed) { if (state == "OVER") { callStopped = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); JAMI_INFO("Start call between alice and Bob"); - auto call = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto call = libjami::placeCallWithMedia(aliceId, bobUri, {}); // Bob not there, so we should get a SEARCHING STATUS JAMI_INFO("Wait OVER state"); @@ -245,12 +245,12 @@ CallTest::testDeclineMultiDevice() std::condition_variable cv; // Add second device for Bob - std::map> confHandlers; + std::map> confHandlers; auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -267,7 +267,7 @@ CallTest::testDeclineMultiDevice() std::atomic callStopped {0}; std::string callIdBob; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, @@ -277,16 +277,16 @@ CallTest::testDeclineMultiDevice() callReceived += 1; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string&, const std::string& state, signed) { if (state == "OVER") callStopped++; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); JAMI_INFO("Start call between alice and Bob"); - auto call = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto call = libjami::placeCallWithMedia(aliceId, bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&] { return callReceived == 2 && !callIdBob.empty(); @@ -311,12 +311,12 @@ CallTest::testTlsInfosPeerCertificate() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::atomic callStopped {0}; std::string bobCallId; std::string aliceCallState; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, @@ -325,7 +325,7 @@ CallTest::testTlsInfosPeerCertificate() bobCallId = callId; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&, const std::string& state, signed) { if (accountId == aliceId) aliceCallState = state; @@ -335,10 +335,10 @@ CallTest::testTlsInfosPeerCertificate() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); JAMI_INFO("Start call between alice and Bob"); - auto callId = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto callId = libjami::placeCallWithMedia(aliceId, bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&] { return !bobCallId.empty(); })); diff --git a/test/unitTest/call/conference.cpp b/test/unitTest/call/conference.cpp index aab58e0ac..f138eb522 100644 --- a/test/unitTest/call/conference.cpp +++ b/test/unitTest/call/conference.cpp @@ -36,7 +36,7 @@ #include "sip/sipcall.h" #include "sip/siptransport.h" -using namespace DRing::Account; +using namespace libjami::Account; using namespace std::literals::chrono_literals; namespace jami { @@ -74,11 +74,11 @@ public: ConferenceTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~ConferenceTest() { DRing::fini(); } + ~ConferenceTest() { libjami::fini(); } static std::string name() { return "Conference"; } void setUp(); void tearDown(); @@ -188,9 +188,9 @@ ConferenceTest::registerSignalHandlers() auto carlaUri = carlaAccount->getUsername(); auto daviUri = daviAccount->getUsername(); - std::map> confHandlers; + std::map> confHandlers; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string& accountId, const std::string& callId, const std::string&, @@ -205,12 +205,12 @@ ConferenceTest::registerSignalHandlers() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback([=](const std::string& accountId, + libjami::exportable_callback([=](const std::string& accountId, const std::string& callId, const std::string& state, signed) { if (accountId == aliceId) { - auto details = DRing::getCallDetails(aliceId, callId); + auto details = libjami::getCallDetails(aliceId, callId); if (details["PEER_NUMBER"].find(bobUri) != std::string::npos) bobCall.hostState = state; else if (details["PEER_NUMBER"].find(carlaUri) != std::string::npos) @@ -225,24 +225,24 @@ ConferenceTest::registerSignalHandlers() daviCall.state = state; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string&, const std::string& conferenceId) { confId = conferenceId; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string&, const std::string& conferenceId) { if (confId == conferenceId) confId = ""; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string&, const std::string& conferenceId, const std::string&) { if (confId == conferenceId) confChanged = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string&, const std::vector> participantsInfos) { pInfos_ = participantsInfos; @@ -275,7 +275,7 @@ ConferenceTest::registerSignalHandlers() cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); } void @@ -292,23 +292,23 @@ ConferenceTest::startConference(bool audioOnly, bool addDavi) std::vector> mediaList; if (audioOnly) { std::map mediaAttribute - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, - DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}, - {DRing::Media::MediaAttributeKey::LABEL, "audio_0"}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, + libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}, + {libjami::Media::MediaAttributeKey::LABEL, "audio_0"}}; mediaList.emplace_back(mediaAttribute); } JAMI_INFO("Start call between Alice and Bob"); - auto call1 = DRing::placeCallWithMedia(aliceId, bobUri, mediaList); + auto call1 = libjami::placeCallWithMedia(aliceId, bobUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.hostState == "CURRENT"; })); JAMI_INFO("Start call between Alice and Carla"); - auto call2 = DRing::placeCallWithMedia(aliceId, carlaUri, mediaList); + auto call2 = libjami::placeCallWithMedia(aliceId, carlaUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !carlaCall.callId.empty(); })); Manager::instance().answerCall(carlaId, carlaCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return carlaCall.hostState == "CURRENT"; })); @@ -325,7 +325,7 @@ ConferenceTest::startConference(bool audioOnly, bool addDavi) if (addDavi) { JAMI_INFO("Start call between Alice and Davi"); - auto call1 = DRing::placeCallWithMedia(aliceId, daviUri, mediaList); + auto call1 = libjami::placeCallWithMedia(aliceId, daviUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !daviCall.callId.empty(); })); Manager::instance().answerCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.hostState == "CURRENT"; })); @@ -352,18 +352,18 @@ ConferenceTest::testGetConference() { registerSignalHandlers(); - CPPUNIT_ASSERT(DRing::getConferenceList(aliceId).size() == 0); + CPPUNIT_ASSERT(libjami::getConferenceList(aliceId).size() == 0); startConference(); - CPPUNIT_ASSERT(DRing::getConferenceList(aliceId).size() == 1); - CPPUNIT_ASSERT(DRing::getConferenceList(aliceId)[0] == confId); + CPPUNIT_ASSERT(libjami::getConferenceList(aliceId).size() == 1); + CPPUNIT_ASSERT(libjami::getConferenceList(aliceId)[0] == confId); hangupConference(); - CPPUNIT_ASSERT(DRing::getConferenceList(aliceId).size() == 0); + CPPUNIT_ASSERT(libjami::getConferenceList(aliceId).size() == 0); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -377,15 +377,15 @@ ConferenceTest::testModeratorMuteUpdateParticipantsInfos() startConference(); JAMI_INFO("Play with mute from the moderator"); - DRing::muteStream(aliceId, confId, bobUri, bobCall.device, bobCall.streamId, true); + libjami::muteStream(aliceId, confId, bobUri, bobCall.device, bobCall.streamId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return bobCall.moderatorMuted.load(); })); - DRing::muteStream(aliceId, confId, bobUri, bobCall.device, bobCall.streamId, false); + libjami::muteStream(aliceId, confId, bobUri, bobCall.device, bobCall.streamId, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !bobCall.moderatorMuted.load(); })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -399,12 +399,12 @@ ConferenceTest::testUnauthorizedMute() startConference(); JAMI_INFO("Play with mute from unauthorized"); - DRing::muteStream(carlaId, confId, bobUri, bobCall.device, bobCall.streamId, true); + libjami::muteStream(carlaId, confId, bobUri, bobCall.device, bobCall.streamId, true); CPPUNIT_ASSERT(!cv.wait_for(lk, 15s, [&] { return bobCall.moderatorMuted.load(); })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -419,23 +419,23 @@ ConferenceTest::testAudioVideoMutedStates() auto carlaUri = carlaAccount->getUsername(); JAMI_INFO("Start call between Alice and Bob"); - auto call1Id = DRing::placeCallWithMedia(aliceId, bobUri, {}); + auto call1Id = libjami::placeCallWithMedia(aliceId, bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.hostState == "CURRENT"; })); auto call1 = aliceAccount->getCall(call1Id); - call1->muteMedia(DRing::Media::MediaAttributeValue::AUDIO, true); - call1->muteMedia(DRing::Media::MediaAttributeValue::VIDEO, true); + call1->muteMedia(libjami::Media::MediaAttributeValue::AUDIO, true); + call1->muteMedia(libjami::Media::MediaAttributeValue::VIDEO, true); JAMI_INFO("Start call between Alice and Carla"); - auto call2Id = DRing::placeCallWithMedia(aliceId, carlaUri, {}); + auto call2Id = libjami::placeCallWithMedia(aliceId, carlaUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !carlaCall.callId.empty(); })); Manager::instance().answerCall(carlaId, carlaCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return carlaCall.hostState == "CURRENT"; })); auto call2 = aliceAccount->getCall(call2Id); - call2->muteMedia(DRing::Media::MediaAttributeValue::AUDIO, true); - call2->muteMedia(DRing::Media::MediaAttributeValue::VIDEO, true); + call2->muteMedia(libjami::Media::MediaAttributeValue::AUDIO, true); + call2->muteMedia(libjami::Media::MediaAttributeValue::VIDEO, true); JAMI_INFO("Start conference"); Manager::instance().joinParticipant(aliceId, call1Id, aliceId, call2Id); @@ -451,7 +451,7 @@ ConferenceTest::testAudioVideoMutedStates() hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -496,7 +496,7 @@ ConferenceTest::testCreateParticipantsSinks() hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -512,14 +512,14 @@ ConferenceTest::testMuteStatusAfterRemove() startConference(false, true); - DRing::muteStream(aliceId, confId, daviUri, daviCall.device, daviCall.streamId, true); + libjami::muteStream(aliceId, confId, daviUri, daviCall.device, daviCall.streamId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return daviCall.moderatorMuted.load(); })); Manager::instance().hangupCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); daviCall.reset(); - auto call2 = DRing::placeCallWithMedia(aliceId, daviUri, {}); + auto call2 = libjami::placeCallWithMedia(aliceId, daviUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !daviCall.callId.empty(); })); Manager::instance().answerCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.hostState == "CURRENT"; })); @@ -532,7 +532,7 @@ ConferenceTest::testMuteStatusAfterRemove() CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -552,14 +552,14 @@ ConferenceTest::testActiveStatusAfterRemove() defaultAudio.label_ = "audio_0"; defaultAudio.enabled_ = true; - DRing::setActiveStream(aliceId, confId, daviUri, daviCall.device, daviCall.streamId, true); + libjami::setActiveStream(aliceId, confId, daviUri, daviCall.device, daviCall.streamId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return daviCall.active.load(); })); Manager::instance().hangupCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); daviCall.reset(); - auto call2 = DRing::placeCallWithMedia(aliceId, + auto call2 = libjami::placeCallWithMedia(aliceId, daviUri, MediaAttribute::mediaAttributesToMediaMaps( {defaultAudio})); @@ -575,7 +575,7 @@ ConferenceTest::testActiveStatusAfterRemove() CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -594,39 +594,39 @@ ConferenceTest::testHandsUp() startConference(false, true); JAMI_INFO("Play with raise hand"); - DRing::raiseHand(bobId, bobCall.callId, bobUri, bobCall.device, true); + libjami::raiseHand(bobId, bobCall.callId, bobUri, bobCall.device, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return bobCall.raisedHand.load(); })); - DRing::raiseHand(bobId, bobCall.callId, bobUri, bobCall.device, false); + libjami::raiseHand(bobId, bobCall.callId, bobUri, bobCall.device, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !bobCall.raisedHand.load(); })); // Remove davi from moderators - DRing::setModerator(aliceId, confId, daviUri, false); + libjami::setModerator(aliceId, confId, daviUri, false); // Test to raise hand CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !daviCall.device.empty(); })); - DRing::raiseHand(daviId, daviCall.callId, daviUri, daviCall.device, true); + libjami::raiseHand(daviId, daviCall.callId, daviUri, daviCall.device, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return daviCall.raisedHand.load(); })); // Test to raise hand for another one (should fail) - DRing::raiseHand(bobId, bobCall.callId, carlaUri, carlaCall.device, true); + libjami::raiseHand(bobId, bobCall.callId, carlaUri, carlaCall.device, true); CPPUNIT_ASSERT(!cv.wait_for(lk, 5s, [&] { return carlaCall.raisedHand.load(); })); // However, a moderator should be able to lower the hand (but not a non moderator) - DRing::raiseHand(carlaId, carlaCall.callId, carlaUri, carlaCall.device, true); + libjami::raiseHand(carlaId, carlaCall.callId, carlaUri, carlaCall.device, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return carlaCall.raisedHand.load(); })); - DRing::raiseHand(daviId, carlaCall.callId, carlaUri, carlaCall.device, false); + libjami::raiseHand(daviId, carlaCall.callId, carlaUri, carlaCall.device, false); CPPUNIT_ASSERT(!cv.wait_for(lk, 5s, [&] { return !carlaCall.raisedHand.load(); })); - DRing::raiseHand(bobId, bobCall.callId, carlaUri, carlaCall.device, false); + libjami::raiseHand(bobId, bobCall.callId, carlaUri, carlaCall.device, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !carlaCall.raisedHand.load(); })); Manager::instance().hangupCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); daviCall.reset(); - auto call2 = DRing::placeCallWithMedia(aliceId, daviUri, {}); + auto call2 = libjami::placeCallWithMedia(aliceId, daviUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !daviCall.callId.empty(); })); Manager::instance().answerCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.hostState == "CURRENT"; })); @@ -639,7 +639,7 @@ ConferenceTest::testHandsUp() CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.state == "OVER"; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -655,7 +655,7 @@ ConferenceTest::testPeerLeaveConference() Manager::instance().hangupCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.state == "OVER" && confId.empty(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -672,21 +672,21 @@ ConferenceTest::testJoinCallFromOtherAccount() startConference(); JAMI_INFO("Play with raise hand"); - DRing::raiseHand(aliceId, confId, bobUri, bobCall.device, true); + libjami::raiseHand(aliceId, confId, bobUri, bobCall.device, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return bobCall.raisedHand.load(); })); - DRing::raiseHand(aliceId, confId, bobUri, bobCall.device, false); + libjami::raiseHand(aliceId, confId, bobUri, bobCall.device, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !bobCall.raisedHand.load(); })); JAMI_INFO("Start call between Alice and Davi"); - auto call1 = DRing::placeCallWithMedia(aliceId, daviUri, {}); + auto call1 = libjami::placeCallWithMedia(aliceId, daviUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !daviCall.callId.empty(); })); Manager::instance().answerCall(daviId, daviCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return daviCall.hostState == "CURRENT"; })); CPPUNIT_ASSERT(Manager::instance().addParticipant(daviId, daviCall.callId, aliceId, confId)); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -707,7 +707,7 @@ ConferenceTest::testDevices() hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -722,12 +722,12 @@ ConferenceTest::testUnauthorizedSetActive() startConference(); - DRing::setActiveStream(carlaId, confId, bobUri, bobCall.device, bobCall.streamId, true); + libjami::setActiveStream(carlaId, confId, bobUri, bobCall.device, bobCall.streamId, true); CPPUNIT_ASSERT(!cv.wait_for(lk, 15s, [&] { return bobCall.active.load(); })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -743,14 +743,14 @@ ConferenceTest::testHangup() startConference(false, true); - DRing::hangupParticipant(carlaId, confId, daviUri, daviCall.device); // Unauthorized + libjami::hangupParticipant(carlaId, confId, daviUri, daviCall.device); // Unauthorized CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&] { return daviCall.state == "OVER"; })); - DRing::hangupParticipant(aliceId, confId, daviUri, daviCall.device); + libjami::hangupParticipant(aliceId, confId, daviUri, daviCall.device); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return daviCall.state == "OVER"; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -778,7 +778,7 @@ ConferenceTest::testIsConferenceParticipant() CPPUNIT_ASSERT(!aliceAccount->getCall(call2)->isConferenceParticipant()); Manager::instance().hangupCall(aliceId, call2); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -793,22 +793,22 @@ ConferenceTest::testHostAddRmSecondVideo() // Alice adds new media pInfos_.clear(); std::vector> mediaList - = {{{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}, - {DRing::Media::MediaAttributeKey::LABEL, "audio_0"}}, - {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, "bar"}, - {DRing::Media::MediaAttributeKey::LABEL, "video_0"}}, - {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, "foo"}, - {DRing::Media::MediaAttributeKey::LABEL, "video_1"}}}; - DRing::requestMediaChange(aliceId, confId, mediaList); + = {{{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}, + {libjami::Media::MediaAttributeKey::LABEL, "audio_0"}}, + {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, "bar"}, + {libjami::Media::MediaAttributeKey::LABEL, "video_0"}}, + {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, "foo"}, + {libjami::Media::MediaAttributeKey::LABEL, "video_1"}}}; + libjami::requestMediaChange(aliceId, confId, mediaList); // Check that alice has two videos attached to the conference auto aliceVideos = [&]() { @@ -823,14 +823,14 @@ ConferenceTest::testHostAddRmSecondVideo() // Alice removes her second video pInfos_.clear(); mediaList.pop_back(); - DRing::requestMediaChange(aliceId, confId, mediaList); + libjami::requestMediaChange(aliceId, confId, mediaList); // Check that alice has ont video attached to the conference CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceVideos() == 1; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -840,7 +840,7 @@ ConferenceTest::testAudioConferenceConfInfo() startConference(true); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -855,22 +855,22 @@ ConferenceTest::testParticipantAddRmSecondVideo() // Bob adds new media pInfos_.clear(); std::vector> mediaList - = {{{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}, - {DRing::Media::MediaAttributeKey::LABEL, "audio_0"}}, - {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, "bar"}, - {DRing::Media::MediaAttributeKey::LABEL, "video_0"}}, - {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, "true"}, - {DRing::Media::MediaAttributeKey::MUTED, "false"}, - {DRing::Media::MediaAttributeKey::SOURCE, "foo"}, - {DRing::Media::MediaAttributeKey::LABEL, "video_1"}}}; - DRing::requestMediaChange(bobId, bobCall.callId, mediaList); + = {{{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}, + {libjami::Media::MediaAttributeKey::LABEL, "audio_0"}}, + {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, "bar"}, + {libjami::Media::MediaAttributeKey::LABEL, "video_0"}}, + {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, "true"}, + {libjami::Media::MediaAttributeKey::MUTED, "false"}, + {libjami::Media::MediaAttributeKey::SOURCE, "foo"}, + {libjami::Media::MediaAttributeKey::LABEL, "video_1"}}}; + libjami::requestMediaChange(bobId, bobCall.callId, mediaList); // Check that bob has two videos attached to the conference auto bobVideos = [&]() { @@ -885,14 +885,14 @@ ConferenceTest::testParticipantAddRmSecondVideo() // Bob removes his second video pInfos_.clear(); mediaList.pop_back(); - DRing::requestMediaChange(bobId, bobCall.callId, mediaList); + libjami::requestMediaChange(bobId, bobCall.callId, mediaList); // Check that bob has ont video attached to the conference CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return bobVideos() == 1; })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -903,21 +903,21 @@ ConferenceTest::testPropagateRecording() startConference(); JAMI_INFO("Play with recording state"); - DRing::toggleRecording(bobId, bobCall.callId); + libjami::toggleRecording(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return bobCall.recording.load(); })); - DRing::toggleRecording(bobId, bobCall.callId); + libjami::toggleRecording(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !bobCall.recording.load(); })); - DRing::toggleRecording(aliceId, confId); + libjami::toggleRecording(aliceId, confId); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return hostRecording.load(); })); - DRing::toggleRecording(aliceId, confId); + libjami::toggleRecording(aliceId, confId); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return !hostRecording.load(); })); hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -943,7 +943,7 @@ ConferenceTest::testBrokenParticipantAudioAndVideo() hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -969,7 +969,7 @@ ConferenceTest::testBrokenParticipantAudioOnly() hangupConference(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } } // namespace test diff --git a/test/unitTest/call/recorder.cpp b/test/unitTest/call/recorder.cpp index c605cf7b4..621c0d555 100644 --- a/test/unitTest/call/recorder.cpp +++ b/test/unitTest/call/recorder.cpp @@ -34,7 +34,7 @@ #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; using namespace std::literals::chrono_literals; namespace jami { @@ -64,11 +64,11 @@ public: RecorderTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~RecorderTest() { DRing::fini(); } + ~RecorderTest() { libjami::fini(); } static std::string name() { return "Recorder"; } void setUp(); void tearDown(); @@ -113,13 +113,13 @@ RecorderTest::setUp() bobId = actors["bob"]; bobCall.reset(); - DRing::setRecordPath(recordDir); + libjami::setRecordPath(recordDir); } void RecorderTest::tearDown() { - DRing::setIsAlwaysRecording(false); + libjami::setIsAlwaysRecording(false); fileutils::removeAll(recordDir); wait_for_removal_of({aliceId, bobId}); @@ -132,9 +132,9 @@ RecorderTest::registerSignalHandlers() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; + std::map> confHandlers; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [=](const std::string& accountId, const std::string& callId, const std::string&, @@ -145,12 +145,12 @@ RecorderTest::registerSignalHandlers() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback([=](const std::string& accountId, + libjami::exportable_callback([=](const std::string& accountId, const std::string& callId, const std::string& state, signed) { if (accountId == aliceId) { - auto details = DRing::getCallDetails(aliceId, callId); + auto details = libjami::getCallDetails(aliceId, callId); if (details["PEER_NUMBER"].find(bobUri) != std::string::npos) bobCall.hostState = state; } else if (bobCall.callId == callId) @@ -158,7 +158,7 @@ RecorderTest::registerSignalHandlers() cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>&) { @@ -166,12 +166,12 @@ RecorderTest::registerSignalHandlers() bobCall.mediaStatus = event; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& path) { recordedFile = path; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); } void @@ -185,37 +185,37 @@ RecorderTest::testRecordCall() JAMI_INFO("Start call between Alice and Bob"); std::vector> mediaList; std::map mediaAttributeA - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; std::map mediaAttributeV - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; mediaList.emplace_back(mediaAttributeA); mediaList.emplace_back(mediaAttributeV); - auto callId = DRing::placeCallWithMedia(aliceId, bobUri, mediaList); + auto callId = libjami::placeCallWithMedia(aliceId, bobUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.mediaStatus - == DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; + == libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; })); // give time to start camera std::this_thread::sleep_for(5s); // Start recorder recordedFile.clear(); - CPPUNIT_ASSERT(!DRing::getIsRecording(aliceId, callId)); - DRing::toggleRecording(aliceId, callId); + CPPUNIT_ASSERT(!libjami::getIsRecording(aliceId, callId)); + libjami::toggleRecording(aliceId, callId); // Stop recorder after a few seconds std::this_thread::sleep_for(5s); - CPPUNIT_ASSERT(DRing::getIsRecording(aliceId, callId)); - DRing::toggleRecording(aliceId, callId); - CPPUNIT_ASSERT(!DRing::getIsRecording(aliceId, callId)); + CPPUNIT_ASSERT(libjami::getIsRecording(aliceId, callId)); + libjami::toggleRecording(aliceId, callId); + CPPUNIT_ASSERT(!libjami::getIsRecording(aliceId, callId)); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !recordedFile.empty(); })); @@ -234,28 +234,28 @@ RecorderTest::testRecordAudioOnlyCall() JAMI_INFO("Start call between Alice and Bob"); std::vector> mediaList; std::map mediaAttribute - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; mediaList.emplace_back(mediaAttribute); - auto callId = DRing::placeCallWithMedia(aliceId, bobUri, mediaList); + auto callId = libjami::placeCallWithMedia(aliceId, bobUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.mediaStatus - == DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; + == libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; })); // Start recorder recordedFile.clear(); - DRing::toggleRecording(aliceId, callId); + libjami::toggleRecording(aliceId, callId); // Stop recorder std::this_thread::sleep_for(5s); - CPPUNIT_ASSERT(DRing::getIsRecording(aliceId, callId)); - DRing::toggleRecording(aliceId, callId); - CPPUNIT_ASSERT(!DRing::getIsRecording(aliceId, callId)); + CPPUNIT_ASSERT(libjami::getIsRecording(aliceId, callId)); + libjami::toggleRecording(aliceId, callId); + CPPUNIT_ASSERT(!libjami::getIsRecording(aliceId, callId)); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !recordedFile.empty() && recordedFile.find(".ogg") != std::string::npos; @@ -276,30 +276,30 @@ RecorderTest::testStopCallWhileRecording() JAMI_INFO("Start call between Alice and Bob"); std::vector> mediaList; std::map mediaAttributeA - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; std::map mediaAttributeV - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::VIDEO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::VIDEO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; mediaList.emplace_back(mediaAttributeA); mediaList.emplace_back(mediaAttributeV); - auto callId = DRing::placeCallWithMedia(aliceId, bobUri, mediaList); + auto callId = libjami::placeCallWithMedia(aliceId, bobUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.mediaStatus - == DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; + == libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; })); // give time to start camera std::this_thread::sleep_for(5s); // Start recorder recordedFile.clear(); - DRing::toggleRecording(aliceId, callId); + libjami::toggleRecording(aliceId, callId); // Hangup call std::this_thread::sleep_for(5s); @@ -316,23 +316,23 @@ RecorderTest::testDaemonPreference() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - DRing::setIsAlwaysRecording(true); + libjami::setIsAlwaysRecording(true); recordedFile.clear(); JAMI_INFO("Start call between Alice and Bob"); std::vector> mediaList; std::map mediaAttributeA - = {{DRing::Media::MediaAttributeKey::MEDIA_TYPE, DRing::Media::MediaAttributeValue::AUDIO}, - {DRing::Media::MediaAttributeKey::ENABLED, TRUE_STR}, - {DRing::Media::MediaAttributeKey::MUTED, FALSE_STR}, - {DRing::Media::MediaAttributeKey::SOURCE, ""}}; + = {{libjami::Media::MediaAttributeKey::MEDIA_TYPE, libjami::Media::MediaAttributeValue::AUDIO}, + {libjami::Media::MediaAttributeKey::ENABLED, TRUE_STR}, + {libjami::Media::MediaAttributeKey::MUTED, FALSE_STR}, + {libjami::Media::MediaAttributeKey::SOURCE, ""}}; mediaList.emplace_back(mediaAttributeA); - auto callId = DRing::placeCallWithMedia(aliceId, bobUri, mediaList); + auto callId = libjami::placeCallWithMedia(aliceId, bobUri, mediaList); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return !bobCall.callId.empty(); })); Manager::instance().answerCall(bobId, bobCall.callId); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return bobCall.mediaStatus - == DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; + == libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS; })); // Let record some seconds diff --git a/test/unitTest/certstore.cpp b/test/unitTest/certstore.cpp index d1d9a272c..13e2fe42a 100644 --- a/test/unitTest/certstore.cpp +++ b/test/unitTest/certstore.cpp @@ -152,10 +152,10 @@ CertStoreTest::trustStoreTest() // Test statusToStr CPPUNIT_ASSERT(strcmp(jami::tls::statusToStr(jami::tls::TrustStatus::TRUSTED), - DRing::Certificate::TrustStatus::TRUSTED) + libjami::Certificate::TrustStatus::TRUSTED) == 0); CPPUNIT_ASSERT(strcmp(jami::tls::statusToStr(jami::tls::TrustStatus::UNTRUSTED), - DRing::Certificate::TrustStatus::UNTRUSTED) + libjami::Certificate::TrustStatus::UNTRUSTED) == 0); } diff --git a/test/unitTest/common.cpp b/test/unitTest/common.cpp index 705682e8d..84677525b 100644 --- a/test/unitTest/common.cpp +++ b/test/unitTest/common.cpp @@ -40,7 +40,7 @@ void wait_for_announcement_of(const std::vector accountIDs, std::chrono::seconds timeout) { - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; @@ -49,7 +49,7 @@ wait_for_announcement_of(const std::vector accountIDs, size_t to_be_announced = accountIDs.size(); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&, accountIDs = std::move(accountIDs)](const std::string& accountID, const std::map& details) { @@ -60,7 +60,7 @@ wait_for_announcement_of(const std::vector accountIDs, try { if ("true" - != details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED)) { + != details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED)) { continue; } } catch (const std::out_of_range&) { @@ -74,7 +74,7 @@ wait_for_announcement_of(const std::vector accountIDs, JAMI_DBG("Waiting for %zu account to be announced...", to_be_announced); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); CPPUNIT_ASSERT(cv.wait_for(lk, timeout, [&] { for (const auto& rdy : accountsReady) { @@ -86,7 +86,7 @@ wait_for_announcement_of(const std::vector accountIDs, return true; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_DBG("%zu account announced!", to_be_announced); } @@ -104,7 +104,7 @@ wait_for_removal_of(const std::vector accounts, { JAMI_INFO("Removing %zu accounts...", accounts.size()); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; @@ -118,15 +118,15 @@ wait_for_removal_of(const std::vector accounts, size_t target = current - accounts.size(); confHandlers.insert( - DRing::exportable_callback([&]() { + libjami::exportable_callback([&]() { if (jami::Manager::instance().getAccountList().size() <= target) { accountsRemoved = true; cv.notify_one(); } })); - DRing::unregisterSignalHandlers(); - DRing::registerSignalHandlers(confHandlers); + libjami::unregisterSignalHandlers(); + libjami::registerSignalHandlers(confHandlers); for (const auto& account : accounts) { jami::Manager::instance().removeAccount(account, true); @@ -134,7 +134,7 @@ wait_for_removal_of(const std::vector accounts, CPPUNIT_ASSERT(cv.wait_for(lk, timeout, [&] { return accountsRemoved.load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -148,7 +148,7 @@ std::map load_actors(const std::string& from_yaml) { std::map actors {}; - std::map default_details = DRing::getAccountTemplate("RING"); + std::map default_details = libjami::getAccountTemplate("RING"); std::ifstream file = jami::fileutils::ifstream(from_yaml); diff --git a/test/unitTest/connectionManager/connectionManager.cpp b/test/unitTest/connectionManager/connectionManager.cpp index 3861ef992..efdb17f28 100644 --- a/test/unitTest/connectionManager/connectionManager.cpp +++ b/test/unitTest/connectionManager/connectionManager.cpp @@ -31,7 +31,7 @@ #include "account_const.h" #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; using namespace std::literals::chrono_literals; namespace jami { @@ -43,11 +43,11 @@ public: ConnectionManagerTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~ConnectionManagerTest() { DRing::fini(); } + ~ConnectionManagerTest() { libjami::fini(); } static std::string name() { return "ConnectionManager"; } void setUp(); void tearDown(); diff --git a/test/unitTest/conversation/compability.cpp b/test/unitTest/conversation/compability.cpp index 7e2606f42..17ba07ca2 100644 --- a/test/unitTest/conversation/compability.cpp +++ b/test/unitTest/conversation/compability.cpp @@ -37,7 +37,7 @@ #include "account_const.h" using namespace std::string_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -45,7 +45,7 @@ namespace test { class CompabilityTest : public CppUnit::TestFixture { public: - ~CompabilityTest() { DRing::fini(); } + ~CompabilityTest() { libjami::fini(); } static std::string name() { return "Compability"; } void setUp(); void tearDown(); @@ -69,11 +69,11 @@ void CompabilityTest::setUp() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE"; details[ConfProperties::ALIAS] = "ALICE"; @@ -83,7 +83,7 @@ CompabilityTest::setUp() details[ConfProperties::ARCHIVE_PATH] = ""; aliceId = Manager::instance().addAccount(details); - details = DRing::getAccountTemplate("RING"); + details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB"; details[ConfProperties::ALIAS] = "BOB"; @@ -96,30 +96,30 @@ CompabilityTest::setUp() JAMI_INFO("Initialize account..."); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { bool ready = false; auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; ready = (daemonStatus == "REGISTERED"); details = bobAccount->getVolatileAccountDetails(); - daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; ready &= (daemonStatus == "REGISTERED"); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); cv.wait_for(lk, std::chrono::seconds(30)); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void CompabilityTest::tearDown() { - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); auto currentAccSize = Manager::instance().getAccountList().size(); Manager::instance().removeAccount(aliceId, true); Manager::instance().removeAccount(bobId, true); @@ -145,10 +145,10 @@ CompabilityTest::testIsComposing() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationRemoved = false, requestReceived = false, aliceComposing = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -158,14 +158,14 @@ CompabilityTest::testIsComposing() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == aliceId) { conversationRemoved = true; @@ -173,7 +173,7 @@ CompabilityTest::testIsComposing() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -183,7 +183,7 @@ CompabilityTest::testIsComposing() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !convId.empty() && requestReceived; @@ -197,7 +197,7 @@ CompabilityTest::testIsComposing() aliceAccount->setIsComposing("jami:" + bobUri, false); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !aliceComposing; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -210,10 +210,10 @@ CompabilityTest::testSendFileCompatibility() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool successfullyReceive = false, requestReceived = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -223,7 +223,7 @@ CompabilityTest::testSendFileCompatibility() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -236,7 +236,7 @@ CompabilityTest::testSendFileCompatibility() cv.notify_one(); return true; }); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(5), [&]() { return !convId.empty(); })); ConversationRepository repo(aliceAccount, convId); @@ -259,7 +259,7 @@ CompabilityTest::testSendFileCompatibility() sendFile.close(); // Send File - DRing::sendFile(aliceId, convId, "SEND", "SEND", ""); + libjami::sendFile(aliceId, convId, "SEND", "SEND", ""); cv.wait_for(lk, std::chrono::seconds(30), [&]() { return successfullyReceive; }); std::remove("SEND"); diff --git a/test/unitTest/conversation/conversation.cpp b/test/unitTest/conversation/conversation.cpp index 4c677bcbd..644f70e24 100644 --- a/test/unitTest/conversation/conversation.cpp +++ b/test/unitTest/conversation/conversation.cpp @@ -41,7 +41,7 @@ using namespace std::string_literals; using namespace std::literals::chrono_literals; -using namespace DRing::Account; +using namespace libjami::Account; struct ConvInfoTest { @@ -59,7 +59,7 @@ namespace test { class ConversationTest : public CppUnit::TestFixture { public: - ~ConversationTest() { DRing::fini(); } + ~ConversationTest() { libjami::fini(); } static std::string name() { return "Conversation"; } void setUp(); void tearDown(); @@ -173,9 +173,9 @@ void ConversationTest::setUp() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); auto actors = load_actors("actors/alice-bob-carla.yml"); aliceId = actors["alice"]; @@ -209,19 +209,19 @@ ConversationTest::testCreateConversation() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == aliceId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); cv.wait_for(lk, 30s, [&]() { return conversationReady; }); CPPUNIT_ASSERT(conversationReady); ConversationRepository repo(aliceAccount, convId); @@ -254,9 +254,9 @@ ConversationTest::testGetConversation() { auto aliceAccount = Manager::instance().getAccount(aliceId); auto uri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - auto conversations = DRing::getConversations(aliceId); + auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); CPPUNIT_ASSERT(conversations.front() == convId); } @@ -270,25 +270,25 @@ ConversationTest::testGetConversationsAfterRm() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == aliceId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto conversations = DRing::getConversations(aliceId); + auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); - CPPUNIT_ASSERT(DRing::removeConversation(aliceId, convId)); - conversations = DRing::getConversations(aliceId); + CPPUNIT_ASSERT(libjami::removeConversation(aliceId, convId)); + conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 0); } @@ -301,25 +301,25 @@ ConversationTest::testRemoveInvalidConversation() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == aliceId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto conversations = DRing::getConversations(aliceId); + auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); - CPPUNIT_ASSERT(!DRing::removeConversation(aliceId, "foo")); - conversations = DRing::getConversations(aliceId); + CPPUNIT_ASSERT(!libjami::removeConversation(aliceId, "foo")); + conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); } @@ -333,11 +333,11 @@ ConversationTest::testSendMessage() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -349,28 +349,28 @@ ConversationTest::testSendMessage() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Assert that repository exists @@ -380,7 +380,7 @@ ConversationTest::testSendMessage() // Wait that alice sees Bob cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; }); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); } @@ -394,9 +394,9 @@ ConversationTest::testReplaceWithBadCertificate() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -409,7 +409,7 @@ ConversationTest::testReplaceWithBadCertificate() })); auto requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -417,7 +417,7 @@ ConversationTest::testReplaceWithBadCertificate() cv.notify_one(); })); auto conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -425,7 +425,7 @@ ConversationTest::testReplaceWithBadCertificate() } })); auto errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -434,14 +434,14 @@ ConversationTest::testReplaceWithBadCertificate() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Wait that alice sees Bob @@ -461,7 +461,7 @@ ConversationTest::testReplaceWithBadCertificate() std::filesystem::copy_options::overwrite_existing); addAll(aliceAccount, convId); - // Note: Do not use DRing::sendMessage as it will replace the invalid certificate by a valid one + // Note: Do not use libjami::sendMessage as it will replace the invalid certificate by a valid one Json::Value root; root["type"] = "text/plain"; root["body"] = "hi"; @@ -472,7 +472,7 @@ ConversationTest::testReplaceWithBadCertificate() messageBobReceived = 0; commitInRepo(repoPath, aliceAccount, message); // now we need to sync! - DRing::sendMessage(aliceId, convId, "trigger sync!"s, ""); + libjami::sendMessage(aliceId, convId, "trigger sync!"s, ""); // We should detect the incorrect commit! cv.wait_for(lk, 30s, [&]() { return errorDetected; }); } @@ -484,30 +484,30 @@ ConversationTest::testSendMessageTriggerMessageReceived() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageReceived = 0; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, std::map /*message*/) { messageReceived += 1; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */) { conversationReady = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); cv.wait_for(lk, 30s, [&] { return conversationReady; }); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); cv.wait_for(lk, 30s, [&] { return messageReceived == 1; }); CPPUNIT_ASSERT(messageReceived == 1); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -519,21 +519,21 @@ ConversationTest::testMergeTwoDifferentHeads() auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); carlaAccount->trackBuddyPresence(aliceUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, carlaGotMessage = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /* message */) { @@ -542,7 +542,7 @@ ConversationTest::testMergeTwoDifferentHeads() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); @@ -564,15 +564,15 @@ ConversationTest::testMergeTwoDifferentHeads() ConversationRepository repo(carlaAccount, convId); repo.join(); - DRing::sendMessage(aliceId, convId, "hi"s, ""); - DRing::sendMessage(aliceId, convId, "sup"s, ""); - DRing::sendMessage(aliceId, convId, "jami"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "sup"s, ""); + libjami::sendMessage(aliceId, convId, "jami"s, ""); // Start Carla, should merge and all messages should be there Manager::instance().sendRegister(carlaId, true); carlaGotMessage = false; CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaGotMessage; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -584,14 +584,14 @@ ConversationTest::testMergeAfterMigration() auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); carlaAccount->trackBuddyPresence(aliceUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; @@ -599,7 +599,7 @@ ConversationTest::testMergeAfterMigration() } })); std::string carlaGotMessage, aliceGotMessage; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -612,16 +612,16 @@ ConversationTest::testMergeAfterMigration() })); bool carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); @@ -648,10 +648,10 @@ ConversationTest::testMergeAfterMigration() // Makes different heads carlaAccount->convModule()->loadConversations(); // necessary to load conversation carlaGotMessage = ""; - DRing::sendMessage(carlaId, convId, "hi"s, ""); + libjami::sendMessage(carlaId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return !carlaGotMessage.empty(); })); aliceGotMessage = ""; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return !aliceGotMessage.empty(); })); // Connect only carla to migrate it. @@ -671,7 +671,7 @@ ConversationTest::testMergeAfterMigration() aliceGotMessage = ""; CPPUNIT_ASSERT( cv.wait_for(lk, 60s, [&] { return !carlaGotMessage.empty() && !aliceGotMessage.empty(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -685,34 +685,34 @@ ConversationTest::testSendMessageToMultipleParticipants() aliceAccount->trackBuddyPresence(carlaUri, true); // Enable carla - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; bool carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); confHandlers.clear(); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); auto messageReceivedAlice = 0; auto messageReceivedBob = 0; auto messageReceivedCarla = 0; auto requestReceived = 0; auto conversationReady = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -726,7 +726,7 @@ ConversationTest::testSendMessageToMultipleParticipants() })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -734,22 +734,22 @@ ConversationTest::testSendMessageToMultipleParticipants() cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */) { conversationReady += 1; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return requestReceived == 2; })); messageReceivedAlice = 0; - DRing::acceptConversationRequest(bobId, convId); - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(carlaId, convId); // >= because we can have merges cause the accept commits CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady == 3 && messageReceivedAlice >= 2; @@ -763,11 +763,11 @@ ConversationTest::testSendMessageToMultipleParticipants() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; CPPUNIT_ASSERT(fileutils::isDirectory(repoPath)); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return messageReceivedBob >= 1 && messageReceivedCarla >= 1; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -779,11 +779,11 @@ ConversationTest::testPingPongMessages() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -794,26 +794,26 @@ ConversationTest::testPingPongMessages() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + auto convId = libjami::startConversation(aliceId); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 60s, [&]() { return conversationReady && messageAliceReceived == 1; })); // Assert that repository exists @@ -822,23 +822,23 @@ ConversationTest::testPingPongMessages() CPPUNIT_ASSERT(fileutils::isDirectory(repoPath)); messageBobReceived = 0; messageAliceReceived = 0; - DRing::sendMessage(aliceId, convId, "ping"s, ""); + libjami::sendMessage(aliceId, convId, "ping"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1 && messageAliceReceived == 1; })); - DRing::sendMessage(bobId, convId, "pong"s, ""); + libjami::sendMessage(bobId, convId, "pong"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 2 && messageAliceReceived == 2; })); - DRing::sendMessage(bobId, convId, "ping"s, ""); + libjami::sendMessage(bobId, convId, "ping"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 3 && messageAliceReceived == 3; })); - DRing::sendMessage(aliceId, convId, "pong"s, ""); + libjami::sendMessage(aliceId, convId, "pong"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 4 && messageAliceReceived == 4; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -848,29 +848,29 @@ ConversationTest::testIsComposing() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, aliceComposing = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -880,7 +880,7 @@ ConversationTest::testIsComposing() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -890,8 +890,8 @@ ConversationTest::testIsComposing() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Assert that repository exists auto repoPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + aliceAccount->getAccountID() @@ -902,7 +902,7 @@ ConversationTest::testIsComposing() CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); aliceAccount->setIsComposing("swarm:" + convId, true); @@ -919,28 +919,28 @@ ConversationTest::testMessageStatus() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -952,7 +952,7 @@ ConversationTest::testMessageStatus() })); bool sending = false, sent = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -966,8 +966,8 @@ ConversationTest::testMessageStatus() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Assert that repository exists auto repoPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + aliceAccount->getAccountID() @@ -978,15 +978,15 @@ ConversationTest::testMessageStatus() CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); sending = false; sent = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return sending && sent; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -996,29 +996,29 @@ ConversationTest::testSetMessageDisplayed() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, msgDisplayed = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1030,7 +1030,7 @@ ConversationTest::testSetMessageDisplayed() })); std::string aliceLastMsg; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -1044,9 +1044,9 @@ ConversationTest::testSetMessageDisplayed() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceLastMsg = ""; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && !aliceLastMsg.empty(); })); // Assert that repository exists @@ -1058,18 +1058,18 @@ ConversationTest::testSetMessageDisplayed() CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Last displayed messages should not be set yet - auto membersInfos = DRing::getConversationMembers(bobId, convId); + auto membersInfos = libjami::getConversationMembers(bobId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { return infos["uri"] == aliceUri && infos["lastDisplayed"] == ""; }) != membersInfos.end()); - membersInfos = DRing::getConversationMembers(aliceId, convId); + membersInfos = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1083,7 +1083,7 @@ ConversationTest::testSetMessageDisplayed() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return msgDisplayed; })); // Now, the last displayed message should be updated in member's infos (both sides) - membersInfos = DRing::getConversationMembers(bobId, convId); + membersInfos = libjami::getConversationMembers(bobId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1091,7 +1091,7 @@ ConversationTest::testSetMessageDisplayed() && infos["lastDisplayed"] == convId; }) != membersInfos.end()); - membersInfos = DRing::getConversationMembers(aliceId, convId); + membersInfos = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1100,7 +1100,7 @@ ConversationTest::testSetMessageDisplayed() }) != membersInfos.end()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1110,29 +1110,29 @@ ConversationTest::testSetMessageDisplayedTwice() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, msgDisplayed = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1144,7 +1144,7 @@ ConversationTest::testSetMessageDisplayedTwice() })); std::string aliceLastMsg; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -1158,9 +1158,9 @@ ConversationTest::testSetMessageDisplayedTwice() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceLastMsg = ""; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && !aliceLastMsg.empty(); })); // Assert that repository exists @@ -1172,7 +1172,7 @@ ConversationTest::testSetMessageDisplayedTwice() CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); @@ -1182,7 +1182,7 @@ ConversationTest::testSetMessageDisplayedTwice() aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return msgDisplayed; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1192,29 +1192,29 @@ ConversationTest::testSetMessageDisplayedPreference() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, msgDisplayed = false, aliceRegistered = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1225,7 +1225,7 @@ ConversationTest::testSetMessageDisplayedPreference() })); std::string aliceLastMsg; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& peer, @@ -1240,34 +1240,34 @@ ConversationTest::testSetMessageDisplayedPreference() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (daemonStatus == "REGISTERED") { aliceRegistered = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); auto details = aliceAccount->getAccountDetails(); CPPUNIT_ASSERT(details[ConfProperties::SENDREADRECEIPT] == "true"); details[ConfProperties::SENDREADRECEIPT] = "false"; - DRing::setAccountDetails(aliceId, details); + libjami::setAccountDetails(aliceId, details); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceRegistered; })); aliceLastMsg = ""; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated && !aliceLastMsg.empty(); })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Last displayed messages should not be set yet - auto membersInfos = DRing::getConversationMembers(aliceId, convId); + auto membersInfos = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1282,7 +1282,7 @@ ConversationTest::testSetMessageDisplayedPreference() CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return msgDisplayed; })); // Assert that message is set as displayed for self (for the read status) - membersInfos = DRing::getConversationMembers(aliceId, convId); + membersInfos = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1290,7 +1290,7 @@ ConversationTest::testSetMessageDisplayedPreference() && infos["lastDisplayed"] == convId; }) != membersInfos.end()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } std::string @@ -1467,7 +1467,7 @@ ConversationTest::testVoteNonEmpty() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -1475,19 +1475,19 @@ ConversationTest::testVoteNonEmpty() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; @@ -1495,16 +1495,16 @@ ConversationTest::testVoteNonEmpty() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1518,7 +1518,7 @@ ConversationTest::testVoteNonEmpty() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1527,22 +1527,22 @@ ConversationTest::testVoteNonEmpty() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); @@ -1566,12 +1566,12 @@ ConversationTest::testNoBadFileInInitialCommit() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool carlaConnected = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -1583,7 +1583,7 @@ ConversationTest::testNoBadFileInInitialCommit() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -1591,16 +1591,16 @@ ConversationTest::testNoBadFileInInitialCommit() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1609,14 +1609,14 @@ ConversationTest::testNoBadFileInInitialCommit() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); - DRing::addConversationMember(carlaId, convId, aliceUri); + libjami::addConversationMember(carlaId, convId, aliceUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(aliceId, convId); + libjami::acceptConversationRequest(aliceId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); } @@ -1639,12 +1639,12 @@ ConversationTest::testNoBadCertInInitialCommit() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool carlaConnected = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -1656,7 +1656,7 @@ ConversationTest::testNoBadCertInInitialCommit() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -1664,16 +1664,16 @@ ConversationTest::testNoBadCertInInitialCommit() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1682,14 +1682,14 @@ ConversationTest::testNoBadCertInInitialCommit() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); - DRing::addConversationMember(carlaId, convId, aliceUri); + libjami::addConversationMember(carlaId, convId, aliceUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(aliceId, convId); + libjami::acceptConversationRequest(aliceId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); } @@ -1703,14 +1703,14 @@ ConversationTest::testPlainTextNoBadFile() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0; bool memberMessageGenerated = false; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - std::string convId = DRing::startConversation(aliceId); - confHandlers.insert(DRing::exportable_callback( + std::string convId = libjami::startConversation(aliceId); + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1723,21 +1723,21 @@ ConversationTest::testPlainTextNoBadFile() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1746,14 +1746,14 @@ ConversationTest::testPlainTextNoBadFile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); cv.wait_for(lk, 30s, [&] { return conversationReady && memberMessageGenerated; }); addFile(aliceAccount, convId, "BADFILE"); @@ -1762,10 +1762,10 @@ ConversationTest::testPlainTextNoBadFile() root["body"] = "hi"; commit(aliceAccount, convId, root); errorDetected = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); // Check not received due to the unwanted file CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1775,7 +1775,7 @@ ConversationTest::testVoteNoBadFile() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -1783,20 +1783,20 @@ ConversationTest::testVoteNoBadFile() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, messageCarlaReceived = false, carlaConnected = true; ; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; @@ -1804,16 +1804,16 @@ ConversationTest::testVoteNoBadFile() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1834,35 +1834,35 @@ ConversationTest::testVoteNoBadFile() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); // Now Alice remove Carla without a vote. Bob will not receive the message messageBobReceived = false; addFile(aliceAccount, convId, "BADFILE"); - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); messageCarlaReceived = false; - DRing::sendMessage(bobId, convId, "final"s, ""); + libjami::sendMessage(bobId, convId, "final"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageCarlaReceived; })); } @@ -1876,12 +1876,12 @@ ConversationTest::testETooBigClone() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -1893,21 +1893,21 @@ ConversationTest::testETooBigClone() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1916,9 +1916,9 @@ ConversationTest::testETooBigClone() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); // Assert that repository exists auto repoPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + aliceAccount->getAccountID() @@ -1931,13 +1931,13 @@ ConversationTest::testETooBigClone() addAll(aliceAccount, convId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); errorDetected = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1950,12 +1950,12 @@ ConversationTest::testETooBigFetch() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -1967,21 +1967,21 @@ ConversationTest::testETooBigFetch() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1990,14 +1990,14 @@ ConversationTest::testETooBigFetch() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); cv.wait_for(lk, 30s, [&]() { return requestReceived; }); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); cv.wait_for(lk, 30s, [&]() { return conversationReady; }); // Wait that alice sees Bob @@ -2018,9 +2018,9 @@ ConversationTest::testETooBigFetch() json["type"] = "text/plain"; commit(aliceAccount, convId, json); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2029,7 +2029,7 @@ ConversationTest::testUnknownModeDetected() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); ConversationRepository repo(aliceAccount, convId); Json::Value json; json["mode"] = 1412; @@ -2041,25 +2041,25 @@ ConversationTest::testUnknownModeDetected() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, errorDetected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2068,7 +2068,7 @@ ConversationTest::testUnknownModeDetected() cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -2077,11 +2077,11 @@ ConversationTest::testUnknownModeDetected() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); errorDetected = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); } @@ -2095,9 +2095,9 @@ ConversationTest::testUpdateProfile() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2110,7 +2110,7 @@ ConversationTest::testUpdateProfile() })); bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -2118,7 +2118,7 @@ ConversationTest::testUpdateProfile() cv.notify_one(); })); bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -2127,7 +2127,7 @@ ConversationTest::testUpdateProfile() })); std::map profileAlice, profileBob; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const auto& accountId, const auto& /* conversationId */, const auto& profile) { if (accountId == aliceId) { profileAlice = profile; @@ -2136,15 +2136,15 @@ ConversationTest::testUpdateProfile() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); @@ -2154,7 +2154,7 @@ ConversationTest::testUpdateProfile() return messageBobReceived == 1 && !profileAlice.empty() && !profileBob.empty(); })); - auto infos = DRing::conversationInfos(bobId, convId); + auto infos = libjami::conversationInfos(bobId, convId); // Verify that we have the same profile everywhere CPPUNIT_ASSERT(infos["title"] == "My awesome swarm"); CPPUNIT_ASSERT(profileAlice["title"] == "My awesome swarm"); @@ -2163,7 +2163,7 @@ ConversationTest::testUpdateProfile() CPPUNIT_ASSERT(profileAlice["description"].empty()); CPPUNIT_ASSERT(profileBob["description"].empty()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2176,9 +2176,9 @@ ConversationTest::testGetProfileRequest() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageAliceReceived = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2188,29 +2188,29 @@ ConversationTest::testGetProfileRequest() })); bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); messageAliceReceived = 0; aliceAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 1; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto infos = DRing::conversationInfos(bobId, convId); + auto infos = libjami::conversationInfos(bobId, convId); CPPUNIT_ASSERT(infos["title"] == "My awesome swarm"); CPPUNIT_ASSERT(infos["description"].empty()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2223,11 +2223,11 @@ ConversationTest::testCheckProfileInConversationRequest() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2239,32 +2239,32 @@ ConversationTest::testCheckProfileInConversationRequest() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); aliceAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto requests = DRing::getConversationRequests(bobId); + auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 1); CPPUNIT_ASSERT(requests.front()["title"] == "My awesome swarm"); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2277,7 +2277,7 @@ ConversationTest::testCheckProfileInTrustRequest() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; std::string convId = ""; std::string vcard = "BEGIN:VCARD\n\ @@ -2285,7 +2285,7 @@ VERSION:2.1\n\ FN:TITLE\n\ DESCRIPTION:DESC\n\ END:VCARD"; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -2297,7 +2297,7 @@ END:VCARD"; requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2306,7 +2306,7 @@ END:VCARD"; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); std::vector payload(vcard.begin(), vcard.end()); aliceAccount->sendTrustRequest(bobUri, payload); @@ -2320,17 +2320,17 @@ ConversationTest::testMemberCannotUpdateProfile() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2342,21 +2342,21 @@ ConversationTest::testMemberCannotUpdateProfile() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, int code, @@ -2365,13 +2365,13 @@ ConversationTest::testMemberCannotUpdateProfile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); @@ -2379,7 +2379,7 @@ ConversationTest::testMemberCannotUpdateProfile() bobAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2388,17 +2388,17 @@ ConversationTest::testUpdateProfileWithBadFile() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2410,21 +2410,21 @@ ConversationTest::testUpdateProfileWithBadFile() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, int code, @@ -2433,13 +2433,13 @@ ConversationTest::testUpdateProfileWithBadFile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); @@ -2455,10 +2455,10 @@ END:VCARD"; root["type"] = "application/update-profile"; commit(aliceAccount, convId, root); errorDetected = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2467,17 +2467,17 @@ ConversationTest::testFetchProfileUnauthorized() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -2489,21 +2489,21 @@ ConversationTest::testFetchProfileUnauthorized() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, int code, @@ -2512,13 +2512,13 @@ ConversationTest::testFetchProfileUnauthorized() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageAliceReceived = 0; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); @@ -2533,10 +2533,10 @@ END:VCARD"; root["type"] = "application/update-profile"; commit(bobAccount, convId, root); errorDetected = false; - DRing::sendMessage(bobId, convId, "hi"s, ""); + libjami::sendMessage(bobId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -2544,9 +2544,9 @@ ConversationTest::testDoNotLoadIncorrectConversation() { auto aliceAccount = Manager::instance().getAccount(aliceId); auto uri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - auto convInfos = DRing::conversationInfos(aliceId, convId); + auto convInfos = libjami::conversationInfos(aliceId, convId); CPPUNIT_ASSERT(convInfos.find("mode") != convInfos.end()); CPPUNIT_ASSERT(convInfos.find("syncing") == convInfos.end()); @@ -2560,7 +2560,7 @@ ConversationTest::testDoNotLoadIncorrectConversation() ->loadConversations(); // Refresh. This should detect the incorrect conversations. // the conv should be detected as non existing - convInfos = DRing::conversationInfos(aliceId, convId); + convInfos = libjami::conversationInfos(aliceId, convId); CPPUNIT_ASSERT(convInfos.empty()); } @@ -2574,10 +2574,10 @@ ConversationTest::testSyncingWhileAccepting() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -2587,7 +2587,7 @@ ConversationTest::testSyncingWhileAccepting() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2596,7 +2596,7 @@ ConversationTest::testSyncingWhileAccepting() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -2604,13 +2604,13 @@ ConversationTest::testSyncingWhileAccepting() Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - auto convInfos = DRing::conversationInfos(bobId, convId); + auto convInfos = libjami::conversationInfos(bobId, convId); CPPUNIT_ASSERT(convInfos["syncing"] == "true"); Manager::instance().sendRegister(aliceId, true); // This avoid to sync immediately CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - convInfos = DRing::conversationInfos(bobId, convId); + convInfos = libjami::conversationInfos(bobId, convId); CPPUNIT_ASSERT(convInfos.find("syncing") == convInfos.end()); } @@ -2618,7 +2618,7 @@ void ConversationTest::testCountInteractions() { auto aliceAccount = Manager::instance().getAccount(aliceId); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; @@ -2643,11 +2643,11 @@ ConversationTest::testCountInteractions() }); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !msgId3.empty(); })); - CPPUNIT_ASSERT(DRing::countInteractions(aliceId, convId, "", "", "") == 4 /* 3 + initial */); - CPPUNIT_ASSERT(DRing::countInteractions(aliceId, convId, "", "", aliceAccount->getUsername()) + CPPUNIT_ASSERT(libjami::countInteractions(aliceId, convId, "", "", "") == 4 /* 3 + initial */); + CPPUNIT_ASSERT(libjami::countInteractions(aliceId, convId, "", "", aliceAccount->getUsername()) == 0); - CPPUNIT_ASSERT(DRing::countInteractions(aliceId, convId, msgId3, "", "") == 0); - CPPUNIT_ASSERT(DRing::countInteractions(aliceId, convId, msgId2, "", "") == 1); + CPPUNIT_ASSERT(libjami::countInteractions(aliceId, convId, msgId3, "", "") == 0); + CPPUNIT_ASSERT(libjami::countInteractions(aliceId, convId, msgId2, "", "") == 1); } void @@ -2660,12 +2660,12 @@ ConversationTest::testReplayConversation() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, conversationRemoved = false, messageReceived = false; std::vector bobMessages; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -2675,7 +2675,7 @@ ConversationTest::testReplayConversation() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2684,13 +2684,13 @@ ConversationTest::testReplayConversation() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == aliceId) conversationRemoved = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2703,7 +2703,7 @@ ConversationTest::testReplayConversation() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); @@ -2721,10 +2721,10 @@ ConversationTest::testReplayConversation() aliceAccount->addContact(bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty(); })); messageReceived = false; - DRing::sendMessage(aliceId, convId, "foo"s, ""); + libjami::sendMessage(aliceId, convId, "foo"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); messageReceived = false; - DRing::sendMessage(aliceId, convId, "bar"s, ""); + libjami::sendMessage(aliceId, convId, "bar"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); convId = ""; bobMessages.clear(); @@ -2746,11 +2746,11 @@ ConversationTest::testSyncWithoutPinnedCert() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::string convId = ""; auto requestReceived = false, conversationReady = false, memberMessageGenerated = false, aliceMessageReceived = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -2760,7 +2760,7 @@ ConversationTest::testSyncWithoutPinnedCert() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2769,7 +2769,7 @@ ConversationTest::testSyncWithoutPinnedCert() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2783,30 +2783,30 @@ ConversationTest::testSyncWithoutPinnedCert() })); auto bob2Started = false, aliceStopped = false, bob2Stopped = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto bob2Account = Manager::instance().getAccount(bob2Id); if (!bob2Account) return; auto details = bob2Account->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (daemonStatus == "REGISTERED") bob2Started = true; if (daemonStatus == "UNREGISTERED") bob2Stopped = true; details = aliceAccount->getVolatileAccountDetails(); - daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (daemonStatus == "UNREGISTERED") aliceStopped = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2832,7 +2832,7 @@ ConversationTest::testSyncWithoutPinnedCert() cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); // Bob send a message - DRing::sendMessage(bobId, convId, "hi"s, ""); + libjami::sendMessage(bobId, convId, "hi"s, ""); cv.wait_for(lk, 30s, [&]() { return aliceMessageReceived; }); // Alice off, bob2 On @@ -2854,7 +2854,7 @@ ConversationTest::testImportMalformedContacts() auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); archiver::compressGzip(malformedContacts, bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2864,9 +2864,9 @@ ConversationTest::testImportMalformedContacts() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); wait_for_announcement_of({bob2Id}); - auto contacts = DRing::getContacts(bob2Id); + auto contacts = libjami::getContacts(bob2Id); CPPUNIT_ASSERT(contacts.size() == 1); - CPPUNIT_ASSERT(contacts[0][DRing::Account::TrustRequest::CONVERSATIONID] == ""); + CPPUNIT_ASSERT(contacts[0][libjami::Account::TrustRequest::CONVERSATIONID] == ""); } void @@ -2895,10 +2895,10 @@ END:VCARD"; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2910,7 +2910,7 @@ END:VCARD"; })); std::string convId = ""; auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2922,7 +2922,7 @@ END:VCARD"; cv.notify_one(); })); auto memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2934,18 +2934,18 @@ END:VCARD"; })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } cv.notify_one(); })); auto conversationRmBob = false, conversationRmBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) conversationRmBob = true; @@ -2954,7 +2954,7 @@ END:VCARD"; cv.notify_one(); })); auto aliceProfileReceivedBob = false, aliceProfileReceivedBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& peerId, const std::string& path) { if (accountId == bobId && peerId == aliceUri) { aliceProfileReceivedBob = true; @@ -2963,13 +2963,13 @@ END:VCARD"; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2986,7 +2986,7 @@ END:VCARD"; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; })); @@ -3000,7 +3000,7 @@ END:VCARD"; // Alice send a message requestReceived = false, requestReceivedBob2 = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); // Re-Add contact should accept and clone the conversation on all devices @@ -3008,7 +3008,7 @@ END:VCARD"; conversationReadyBob2 = false; aliceProfileReceivedBob = false; aliceProfileReceivedBob2 = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2 && aliceProfileReceivedBob && aliceProfileReceivedBob2; @@ -3025,10 +3025,10 @@ ConversationTest::testSendReply() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::vector> messageBobReceived = {}, messageAliceReceived = {}; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -3041,7 +3041,7 @@ ConversationTest::testSendReply() })); bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -3049,21 +3049,21 @@ ConversationTest::testSendReply() cv.notify_one(); })); bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Assert that repository exists @@ -3074,16 +3074,16 @@ ConversationTest::testSendReply() cv.wait_for(lk, 30s, [&]() { return messageAliceReceived.size() == 2; }); messageBobReceived.clear(); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived.size() == 1; })); auto validId = messageBobReceived.at(0).at("id"); - DRing::sendMessage(aliceId, convId, "foo"s, validId); + libjami::sendMessage(aliceId, convId, "foo"s, validId); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == 2; })); CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("reply-to") == validId); // Check if parent doesn't exists, no message is generated - DRing::sendMessage(aliceId, convId, "foo"s, "invalid"); + libjami::sendMessage(aliceId, convId, "foo"s, "invalid"); CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == 3; })); } @@ -3097,12 +3097,12 @@ ConversationTest::testSearchInConv() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, messageReceived = false; std::vector bobMessages; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -3112,7 +3112,7 @@ ConversationTest::testSearchInConv() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -3121,7 +3121,7 @@ ConversationTest::testSearchInConv() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -3135,7 +3135,7 @@ ConversationTest::testSearchInConv() })); std::vector> messages; bool finished = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](uint32_t, const std::string&, const std::string& conversationId, @@ -3145,7 +3145,7 @@ ConversationTest::testSearchInConv() finished = conversationId.empty(); cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); @@ -3155,23 +3155,23 @@ ConversationTest::testSearchInConv() cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); // Add some messages messageReceived = false; - DRing::sendMessage(aliceId, convId, "message 1"s, ""); + libjami::sendMessage(aliceId, convId, "message 1"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); messageReceived = false; - DRing::sendMessage(aliceId, convId, "message 2"s, ""); + libjami::sendMessage(aliceId, convId, "message 2"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); messageReceived = false; - DRing::sendMessage(aliceId, convId, "message 3"s, ""); + libjami::sendMessage(aliceId, convId, "message 3"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); - DRing::searchConversation(aliceId, convId, "", "", "message", "", 0, 0, 0); + libjami::searchConversation(aliceId, convId, "", "", "message", "", 0, 0, 0); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 3 && finished; })); messages.clear(); finished = false; - DRing::searchConversation(aliceId, convId, "", "", "message 2", "", 0, 0, 0); + libjami::searchConversation(aliceId, convId, "", "", "message 2", "", 0, 0, 0); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 1 && finished; })); messages.clear(); finished = false; - DRing::searchConversation(aliceId, convId, "", "", "foo", "", 0, 0, 0); + libjami::searchConversation(aliceId, convId, "", "", "foo", "", 0, 0, 0); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 0 && finished; })); } @@ -3183,40 +3183,40 @@ ConversationTest::testConversationPreferences() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, conversationRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == aliceId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == aliceId) conversationRemoved = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start conversation and set preferences - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); cv.wait_for(lk, 30s, [&]() { return conversationReady; }); - CPPUNIT_ASSERT(DRing::getConversationPreferences(aliceId, convId).size() == 0); - DRing::setConversationPreferences(aliceId, convId, {{"foo", "bar"}}); - auto preferences = DRing::getConversationPreferences(aliceId, convId); + CPPUNIT_ASSERT(libjami::getConversationPreferences(aliceId, convId).size() == 0); + libjami::setConversationPreferences(aliceId, convId, {{"foo", "bar"}}); + auto preferences = libjami::getConversationPreferences(aliceId, convId); CPPUNIT_ASSERT(preferences.size() == 1); CPPUNIT_ASSERT(preferences["foo"] == "bar"); // Update - DRing::setConversationPreferences(aliceId, convId, {{"foo", "bar2"}, {"bar", "foo"}}); - preferences = DRing::getConversationPreferences(aliceId, convId); + libjami::setConversationPreferences(aliceId, convId, {{"foo", "bar2"}, {"bar", "foo"}}); + preferences = libjami::getConversationPreferences(aliceId, convId); CPPUNIT_ASSERT(preferences.size() == 2); CPPUNIT_ASSERT(preferences["foo"] == "bar2"); CPPUNIT_ASSERT(preferences["bar"] == "foo"); // Remove conversations removes its preferences. - CPPUNIT_ASSERT(DRing::removeConversation(aliceId, convId)); + CPPUNIT_ASSERT(libjami::removeConversation(aliceId, convId)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); - CPPUNIT_ASSERT(DRing::getConversationPreferences(aliceId, convId).size() == 0); + CPPUNIT_ASSERT(libjami::getConversationPreferences(aliceId, convId).size() == 0); } void ConversationTest::testConversationPreferencesMultiDevices() @@ -3228,10 +3228,10 @@ ConversationTest::testConversationPreferencesMultiDevices() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -3243,7 +3243,7 @@ ConversationTest::testConversationPreferencesMultiDevices() })); std::string convId = ""; auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -3256,11 +3256,11 @@ ConversationTest::testConversationPreferencesMultiDevices() })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } @@ -3268,7 +3268,7 @@ ConversationTest::testConversationPreferencesMultiDevices() })); std::map preferencesBob, preferencesBob2; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map preferences) { @@ -3278,12 +3278,12 @@ ConversationTest::testConversationPreferencesMultiDevices() preferencesBob2 = preferences; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -3298,10 +3298,10 @@ ConversationTest::testConversationPreferencesMultiDevices() aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2; })); - DRing::setConversationPreferences(bobId, convId, {{"foo", "bar"}, {"bar", "foo"}}); + libjami::setConversationPreferences(bobId, convId, {{"foo", "bar"}, {"bar", "foo"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return preferencesBob.size() == 2 && preferencesBob2.size() == 2; })); @@ -3319,16 +3319,16 @@ ConversationTest::testFixContactDetails() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !convId.empty(); })); @@ -3356,9 +3356,9 @@ ConversationTest::testRemoveOneToOneNotInDetails() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::string convId = "", secondConv; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { if (convId.empty()) @@ -3369,13 +3369,13 @@ ConversationTest::testRemoveOneToOneNotInDetails() cv.notify_one(); })); bool conversationRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& cid) { if (accountId == aliceId && cid == secondConv) conversationRemoved = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !convId.empty(); })); @@ -3407,10 +3407,10 @@ ConversationTest::testMessageEdition() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::vector> messageBobReceived; bool conversationReady = false, memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -3424,14 +3424,14 @@ ConversationTest::testMessageEdition() })); bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -3439,7 +3439,7 @@ ConversationTest::testMessageEdition() } })); auto errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -3448,30 +3448,30 @@ ConversationTest::testMessageEdition() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + auto convId = libjami::startConversation(aliceId); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); auto msgSize = messageBobReceived.size(); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived.size() == msgSize + 1; })); msgSize = messageBobReceived.size(); auto editedId = messageBobReceived.rbegin()->at("id"); - DRing::sendMessage(aliceId, convId, "New body"s, editedId, 1); + libjami::sendMessage(aliceId, convId, "New body"s, editedId, 1); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("edit") == editedId); CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("body") == "New body"); // Not an existing message msgSize = messageBobReceived.size(); - DRing::sendMessage(aliceId, convId, "New body"s, "invalidId", 1); + libjami::sendMessage(aliceId, convId, "New body"s, "invalidId", 1); CPPUNIT_ASSERT( !cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); // Invalid author - DRing::sendMessage(aliceId, convId, "New body"s, convId, 1); + libjami::sendMessage(aliceId, convId, "New body"s, convId, 1); CPPUNIT_ASSERT( !cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); // Add invalid edition @@ -3487,7 +3487,7 @@ ConversationTest::testMessageEdition() auto message = Json::writeString(wbuilder, root); commitInRepo(repoPath, aliceAccount, message); errorDetected = false; - DRing::sendMessage(aliceId, convId, "trigger"s, ""); + libjami::sendMessage(aliceId, convId, "trigger"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); } diff --git a/test/unitTest/conversation/conversationMembersEvent.cpp b/test/unitTest/conversation/conversationMembersEvent.cpp index 8786bf4e3..45ee16b6f 100644 --- a/test/unitTest/conversation/conversationMembersEvent.cpp +++ b/test/unitTest/conversation/conversationMembersEvent.cpp @@ -39,7 +39,7 @@ using namespace std::string_literals; using namespace std::literals::chrono_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -47,7 +47,7 @@ namespace test { class ConversationMembersEventTest : public CppUnit::TestFixture { public: - ~ConversationMembersEventTest() { DRing::fini(); } + ~ConversationMembersEventTest() { libjami::fini(); } static std::string name() { return "ConversationMembersEventTest"; } void setUp(); void tearDown(); @@ -135,9 +135,9 @@ void ConversationMembersEventTest::setUp() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); auto actors = load_actors("actors/alice-bob-carla.yml"); aliceId = actors["alice"]; @@ -201,7 +201,7 @@ ConversationMembersEventTest::generateFakeInvite(std::shared_ptr ac wbuilder["indentation"] = ""; cr.commitMessage(Json::writeString(wbuilder, json)); - DRing::sendMessage(account->getAccountID(), + libjami::sendMessage(account->getAccountID(), convId, "trigger the fake history to be pulled"s, ""); @@ -216,19 +216,19 @@ ConversationMembersEventTest::testRemoveConversationNoMember() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == aliceId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Assert that repository exists @@ -239,11 +239,11 @@ ConversationMembersEventTest::testRemoveConversationNoMember() CPPUNIT_ASSERT(fileutils::isDirectory(repoPath)); CPPUNIT_ASSERT(fileutils::isDirectory(dataPath)); - auto conversations = DRing::getConversations(aliceId); + auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); // Removing the conversation will erase all related files - CPPUNIT_ASSERT(DRing::removeConversation(aliceId, convId)); - conversations = DRing::getConversations(aliceId); + CPPUNIT_ASSERT(libjami::removeConversation(aliceId, convId)); + conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 0); CPPUNIT_ASSERT(!fileutils::isDirectory(repoPath)); CPPUNIT_ASSERT(!fileutils::isDirectory(dataPath)); @@ -255,30 +255,30 @@ ConversationMembersEventTest::testRemoveConversationWithMember() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, bobSeeAliceRemoved = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -294,9 +294,9 @@ ConversationMembersEventTest::testRemoveConversationWithMember() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Assert that repository exists @@ -309,7 +309,7 @@ ConversationMembersEventTest::testRemoveConversationWithMember() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); auto clonedPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + bobAccount->getAccountID() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; @@ -320,7 +320,7 @@ ConversationMembersEventTest::testRemoveConversationWithMember() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); bobSeeAliceRemoved = false; - DRing::removeConversation(aliceId, convId); + libjami::removeConversation(aliceId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobSeeAliceRemoved; })); std::this_thread::sleep_for(3s); CPPUNIT_ASSERT(!fileutils::isDirectory(repoPath)); @@ -332,28 +332,28 @@ ConversationMembersEventTest::testAddMember() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -362,8 +362,8 @@ ConversationMembersEventTest::testAddMember() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Assert that repository exists auto repoPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + aliceAccount->getAccountID() @@ -373,7 +373,7 @@ ConversationMembersEventTest::testAddMember() auto bobInvited = repoPath + DIR_SEPARATOR_STR + "invited" + DIR_SEPARATOR_STR + bobUri; CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); auto clonedPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + bobAccount->getAccountID() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; @@ -391,28 +391,28 @@ ConversationMembersEventTest::testMemberAddedNoBadFile() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, errorDetected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, int code, @@ -421,7 +421,7 @@ ConversationMembersEventTest::testMemberAddedNoBadFile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); addFile(aliceAccount, convId, "BADFILE"); generateFakeInvite(aliceAccount, convId, bobUri); // Generate conv request @@ -430,9 +430,9 @@ ConversationMembersEventTest::testMemberAddedNoBadFile() "{\"conversationId\":\"" + convId + "\"}"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); errorDetected = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -442,14 +442,14 @@ ConversationMembersEventTest::testAddOfflineMemberThenConnects() auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; @@ -457,25 +457,25 @@ ConversationMembersEventTest::testAddOfflineMemberThenConnects() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return requestReceived; })); - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); cv.wait_for(lk, 30s, [&]() { return conversationReady; }); auto clonedPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + carlaAccount->getAccountID() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; CPPUNIT_ASSERT(fileutils::isDirectory(clonedPath)); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -488,11 +488,11 @@ ConversationMembersEventTest::testGetMembers() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageReceived = false; bool requestReceived = false; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -502,26 +502,26 @@ ConversationMembersEventTest::testGetMembers() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Start a conversation and add member - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); messageReceived = false; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return messageReceived; })); // Assert that repository exists @@ -529,7 +529,7 @@ ConversationMembersEventTest::testGetMembers() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; CPPUNIT_ASSERT(fileutils::isDirectory(repoPath)); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); CPPUNIT_ASSERT(members[0]["uri"] == aliceAccount->getUsername()); CPPUNIT_ASSERT(members[0]["role"] == "admin"); @@ -538,18 +538,18 @@ ConversationMembersEventTest::testGetMembers() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); messageReceived = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); cv.wait_for(lk, 30s, [&]() { return conversationReady; }); - members = DRing::getConversationMembers(bobId, convId); + members = libjami::getConversationMembers(bobId, convId); CPPUNIT_ASSERT(members.size() == 2); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return messageReceived; })); - members = DRing::getConversationMembers(aliceId, convId); + members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); CPPUNIT_ASSERT(members[0]["uri"] == aliceAccount->getUsername()); CPPUNIT_ASSERT(members[0]["role"] == "admin"); CPPUNIT_ASSERT(members[1]["uri"] == bobUri); CPPUNIT_ASSERT(members[1]["role"] == "member"); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -559,29 +559,29 @@ ConversationMembersEventTest::testRemoveMember() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -594,24 +594,24 @@ ConversationMembersEventTest::testRemoveMember() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Now check that alice, has the only admin, can remove bob memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); CPPUNIT_ASSERT(members[0]["uri"] == aliceAccount->getUsername()); CPPUNIT_ASSERT(members[0]["role"] == "admin"); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -621,21 +621,21 @@ ConversationMembersEventTest::testRemovedMemberDoesNotReceiveMessage() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; @@ -643,7 +643,7 @@ ConversationMembersEventTest::testRemovedMemberDoesNotReceiveMessage() } })); bool memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -655,25 +655,25 @@ ConversationMembersEventTest::testRemovedMemberDoesNotReceiveMessage() messageBobReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Now check that alice, has the only admin, can remove bob memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); // Now, bob is banned so they shoud not receive any message messageBobReceived = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return messageBobReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -685,15 +685,15 @@ ConversationMembersEventTest::testRemoveInvitedMember() auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto carlaUri = carlaAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -702,16 +702,16 @@ ConversationMembersEventTest::testRemoveInvitedMember() })); bool carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; @@ -719,7 +719,7 @@ ConversationMembersEventTest::testRemoveInvitedMember() } })); bool voteMessageGenerated = false, memberMessageGenerated = false, carlaMessageReceived; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -732,37 +732,37 @@ ConversationMembersEventTest::testRemoveInvitedMember() carlaMessageReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Add carla Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Invite Alice requestReceived = false; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 3); // Now check that alice, has the only admin, can remove bob memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - members = DRing::getConversationMembers(aliceId, convId); + members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); // Check that Carla is still able to sync - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaMessageReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -772,7 +772,7 @@ ConversationMembersEventTest::testMemberBanNoBadFile() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -780,12 +780,12 @@ ConversationMembersEventTest::testMemberBanNoBadFile() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -793,23 +793,23 @@ ConversationMembersEventTest::testMemberBanNoBadFile() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -823,7 +823,7 @@ ConversationMembersEventTest::testMemberBanNoBadFile() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, int code, @@ -832,31 +832,31 @@ ConversationMembersEventTest::testMemberBanNoBadFile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); memberMessageGenerated = false; voteMessageGenerated = false; addFile(aliceAccount, convId, "BADFILE"); - DRing::removeConversationMember(aliceId, convId, carlaUri); + libjami::removeConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -866,28 +866,28 @@ ConversationMembersEventTest::testMemberTryToRemoveAdmin() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -895,20 +895,20 @@ ConversationMembersEventTest::testMemberTryToRemoveAdmin() memberMessageGenerated = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Now check that alice, has the only admin, can remove bob memberMessageGenerated = false; - DRing::removeConversationMember(bobId, convId, aliceUri); - auto members = DRing::getConversationMembers(aliceId, convId); + libjami::removeConversationMember(bobId, convId, aliceUri); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2 && !memberMessageGenerated); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -918,29 +918,29 @@ ConversationMembersEventTest::testBannedMemberCannotSendMessage() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, aliceMessageReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -955,27 +955,27 @@ ConversationMembersEventTest::testBannedMemberCannotSendMessage() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); // Now check that alice doesn't receive a message from Bob aliceMessageReceived = false; - DRing::sendMessage(bobId, convId, "hi"s, ""); + libjami::sendMessage(bobId, convId, "hi"s, ""); CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return aliceMessageReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -985,29 +985,29 @@ ConversationMembersEventTest::testAdminCanReAddMember() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1020,33 +1020,33 @@ ConversationMembersEventTest::testAdminCanReAddMember() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); // Now check that alice, has the only admin, can remove bob memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); // Then check that bobUri can be re-added memberMessageGenerated = false, voteMessageGenerated = false; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - members = DRing::getConversationMembers(aliceId, convId); + members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1056,7 +1056,7 @@ ConversationMembersEventTest::testMemberCannotBanOther() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -1064,34 +1064,34 @@ ConversationMembersEventTest::testMemberCannotBanOther() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::string&, std::map) { requestReceived = true; cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1105,7 +1105,7 @@ ConversationMembersEventTest::testMemberCannotBanOther() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1114,23 +1114,23 @@ ConversationMembersEventTest::testMemberCannotBanOther() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; memberMessageGenerated = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); @@ -1141,7 +1141,7 @@ ConversationMembersEventTest::testMemberCannotBanOther() simulateRemoval(carlaAccount, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived; })); } @@ -1152,7 +1152,7 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -1160,34 +1160,34 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, carlaConnected = false, messageCarlaReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::string&, std::map) { requestReceived = true; cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1203,7 +1203,7 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1212,23 +1212,23 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; memberMessageGenerated = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); @@ -1236,17 +1236,17 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() memberMessageGenerated = false; messageCarlaReceived = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated && messageCarlaReceived; })); memberMessageGenerated = false; voteMessageGenerated = false; - DRing::addConversationMember(carlaId, convId, bobUri); + libjami::addConversationMember(carlaId, convId, bobUri); CPPUNIT_ASSERT( !cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); } @@ -1257,7 +1257,7 @@ ConversationMembersEventTest::testCheckAdminFakeAVoteIsDetected() auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); @@ -1265,26 +1265,26 @@ ConversationMembersEventTest::testCheckAdminFakeAVoteIsDetected() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, carlaConnected = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1299,16 +1299,16 @@ ConversationMembersEventTest::testCheckAdminFakeAVoteIsDetected() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1317,22 +1317,22 @@ ConversationMembersEventTest::testCheckAdminFakeAVoteIsDetected() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); requestReceived = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); memberMessageGenerated = false; messageBobReceived = false; - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); @@ -1347,29 +1347,29 @@ ConversationMembersEventTest::testAdminCannotKickTheirself() { auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, voteMessageGenerated = false, aliceMessageReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1384,11 +1384,11 @@ ConversationMembersEventTest::testAdminCannotKickTheirself() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - auto members = DRing::getConversationMembers(aliceId, convId); + libjami::registerSignalHandlers(confHandlers); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); - DRing::removeConversationMember(aliceId, convId, aliceUri); - members = DRing::getConversationMembers(aliceId, convId); + libjami::removeConversationMember(aliceId, convId, aliceUri); + members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); } @@ -1403,12 +1403,12 @@ ConversationMembersEventTest::testCommitUnauthorizedUser() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool errorDetected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -1420,21 +1420,21 @@ ConversationMembersEventTest::testCommitUnauthorizedUser() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1443,14 +1443,14 @@ ConversationMembersEventTest::testCommitUnauthorizedUser() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Assert that repository exists @@ -1471,9 +1471,9 @@ ConversationMembersEventTest::testCommitUnauthorizedUser() commitInRepo(repoPath, carlaAccount, message); errorDetected = false; - DRing::sendMessage(bobId, convId, "hi"s, ""); + libjami::sendMessage(bobId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1483,22 +1483,22 @@ ConversationMembersEventTest::testMemberJoinsNoBadFile() auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, errorDetected = false, carlaConnected = false, memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1508,16 +1508,16 @@ ConversationMembersEventTest::testMemberJoinsNoBadFile() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1526,7 +1526,7 @@ ConversationMembersEventTest::testMemberJoinsNoBadFile() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); @@ -1554,10 +1554,10 @@ ConversationMembersEventTest::testMemberJoinsNoBadFile() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); errorDetected = false; - DRing::sendMessage(carlaId, convId, "hi"s, ""); + libjami::sendMessage(carlaId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1567,22 +1567,22 @@ ConversationMembersEventTest::testMemberAddedNoCertificate() auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, errorDetected = false, carlaConnected = false, memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1592,16 +1592,16 @@ ConversationMembersEventTest::testMemberAddedNoCertificate() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1610,7 +1610,7 @@ ConversationMembersEventTest::testMemberAddedNoCertificate() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); @@ -1647,11 +1647,11 @@ ConversationMembersEventTest::testMemberAddedNoCertificate() Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); - DRing::sendMessage(carlaId, convId, "hi"s, ""); + libjami::sendMessage(carlaId, convId, "hi"s, ""); errorDetected = false; CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1661,22 +1661,22 @@ ConversationMembersEventTest::testMemberJoinsInviteRemoved() auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, errorDetected = false, carlaConnected = false, memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == carlaId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1686,16 +1686,16 @@ ConversationMembersEventTest::testMemberJoinsInviteRemoved() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced = details[DRing::Account::VolatileProperties::DEVICE_ANNOUNCED]; + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; if (deviceAnnounced == "true") { carlaConnected = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1704,7 +1704,7 @@ ConversationMembersEventTest::testMemberJoinsInviteRemoved() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); @@ -1746,11 +1746,11 @@ ConversationMembersEventTest::testMemberJoinsInviteRemoved() Manager::instance().sendRegister(carlaId, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); - DRing::sendMessage(carlaId, convId, "hi"s, ""); + libjami::sendMessage(carlaId, convId, "hi"s, ""); errorDetected = false; CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1765,10 +1765,10 @@ ConversationMembersEventTest::testFailAddMemberInOneToOne() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -1778,7 +1778,7 @@ ConversationMembersEventTest::testFailAddMemberInOneToOne() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1787,7 +1787,7 @@ ConversationMembersEventTest::testFailAddMemberInOneToOne() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1796,12 +1796,12 @@ ConversationMembersEventTest::testFailAddMemberInOneToOne() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); memberMessageGenerated = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT(!cv.wait_for(lk, 5s, [&]() { return memberMessageGenerated; })); } @@ -1817,11 +1817,11 @@ ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, messageBob = false, errorDetected = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -1831,7 +1831,7 @@ ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1840,7 +1840,7 @@ ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1852,7 +1852,7 @@ ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, int code, @@ -1861,7 +1861,7 @@ ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() errorDetected = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); @@ -1881,21 +1881,21 @@ ConversationMembersEventTest::testConversationMemberEvent() auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberAddGenerated = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -1903,7 +1903,7 @@ ConversationMembersEventTest::testConversationMemberEvent() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& uri, @@ -1914,8 +1914,8 @@ ConversationMembersEventTest::testConversationMemberEvent() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberAddGenerated; })); // Assert that repository exists auto repoPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + aliceAccount->getAccountID() @@ -1925,7 +1925,7 @@ ConversationMembersEventTest::testConversationMemberEvent() auto bobInvited = repoPath + DIR_SEPARATOR_STR + "invited" + DIR_SEPARATOR_STR + bobUri; CPPUNIT_ASSERT(fileutils::isFile(bobInvited)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); auto clonedPath = fileutils::get_data_dir() + DIR_SEPARATOR_STR + bobAccount->getAccountID() + DIR_SEPARATOR_STR + "conversations" + DIR_SEPARATOR_STR + convId; @@ -1947,10 +1947,10 @@ ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -1960,7 +1960,7 @@ ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1969,7 +1969,7 @@ ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -1977,7 +1977,7 @@ ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - auto members = DRing::getConversationMembers(bobId, convId); + auto members = libjami::getConversationMembers(bobId, convId); CPPUNIT_ASSERT(std::find_if(members.begin(), members.end(), [&](auto memberInfo) { return memberInfo["uri"] == aliceUri; }) @@ -1996,19 +1996,19 @@ ConversationMembersEventTest::testGetConversationMembersWithSelfOneOne() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) convId = conversationId; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(aliceUri); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); - auto members = DRing::getConversationMembers(aliceId, convId); + auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); CPPUNIT_ASSERT(members[0]["uri"] == aliceUri); } @@ -2024,10 +2024,10 @@ ConversationMembersEventTest::testAvoidTwoOneToOne() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2037,7 +2037,7 @@ ConversationMembersEventTest::testAvoidTwoOneToOne() })); std::string convId = ""; auto conversationReadyBob = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2047,7 +2047,7 @@ ConversationMembersEventTest::testAvoidTwoOneToOne() cv.notify_one(); })); auto memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2058,20 +2058,20 @@ ConversationMembersEventTest::testAvoidTwoOneToOne() cv.notify_one(); })); auto conversationRmBob = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) conversationRmBob = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Alice adds bob requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && memberMessageGenerated; })); @@ -2099,10 +2099,10 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2114,7 +2114,7 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() })); std::string convId = ""; auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2126,7 +2126,7 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() cv.notify_one(); })); auto memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2138,18 +2138,18 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } cv.notify_one(); })); auto conversationRmBob = false, conversationRmBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) conversationRmBob = true; @@ -2157,13 +2157,13 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() conversationRmBob2 = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2180,7 +2180,7 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; })); @@ -2210,10 +2210,10 @@ ConversationMembersEventTest::testRemoveRequestBannedMultiDevices() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2225,31 +2225,31 @@ ConversationMembersEventTest::testRemoveRequestBannedMultiDevices() })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } cv.notify_one(); })); auto bob2ContactRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool banned) { if (accountId == bob2Id && uri == aliceUri && banned) { bob2ContactRemoved = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2266,12 +2266,12 @@ ConversationMembersEventTest::testRemoveRequestBannedMultiDevices() aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - CPPUNIT_ASSERT(DRing::getConversationRequests(bob2Id).size() == 1); + CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 1); // Bob bans alice, should update bob2 bobAccount->removeContact(aliceUri, true); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2ContactRemoved; })); - CPPUNIT_ASSERT(DRing::getConversationRequests(bob2Id).size() == 0); + CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 0); } void @@ -2282,15 +2282,15 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2302,18 +2302,18 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } cv.notify_one(); })); auto bob2ContactRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool banned) { if (accountId == bob2Id && uri == aliceUri && banned) { bob2ContactRemoved = true; @@ -2321,7 +2321,7 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() cv.notify_one(); })); auto memberMessageGenerated = false, voteMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2337,7 +2337,7 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() cv.notify_one(); })); auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId && conversationId == convId) { conversationReadyBob = true; @@ -2346,13 +2346,13 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2366,7 +2366,7 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() // Alice adds bob requestReceived = false; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && requestReceived && requestReceivedBob2; })); @@ -2374,19 +2374,19 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() // Alice kick Bob while invited memberMessageGenerated = false; voteMessageGenerated = false; - DRing::removeConversationMember(aliceId, convId, bobUri); + libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); // Alice re-add Bob while invited memberMessageGenerated = false; voteMessageGenerated = false; - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); // bob accepts - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2; })); } @@ -2402,10 +2402,10 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, requestReceivedBob2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -2417,7 +2417,7 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() })); std::string convId; auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -2430,18 +2430,18 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() })); auto bob2Started = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (accountId == bob2Id) { auto daemonStatus = details.at( - DRing::Account::VolatileProperties::DEVICE_ANNOUNCED); + libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); if (daemonStatus == "true") bob2Started = true; } cv.notify_one(); })); auto bob2ContactRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool banned) { if (accountId == bob2Id && uri == aliceUri && banned) { bob2ContactRemoved = true; @@ -2449,7 +2449,7 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() cv.notify_one(); })); auto bobMsgReceived = false, bob2MsgReceived = false, memberMessageGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -2464,7 +2464,7 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() cv.notify_one(); })); auto contactAddedBob = false, contactAddedBob2 = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool) { if (accountId == bobId && uri == aliceUri) { contactAddedBob = true; @@ -2474,13 +2474,13 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -2497,10 +2497,10 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - CPPUNIT_ASSERT(DRing::getConversationRequests(bob2Id).size() == 1); + CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 1); // Accepts requests - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; })); @@ -2511,7 +2511,7 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() // Alice sends messages, bob & bob2 should not get it! bobMsgReceived = false, bob2MsgReceived = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return bobMsgReceived && bob2MsgReceived; })); // Bobs re-add Alice @@ -2522,7 +2522,7 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() // Alice can sends some messages now bobMsgReceived = false, bob2MsgReceived = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgReceived && bob2MsgReceived; })); } diff --git a/test/unitTest/conversation/conversationRequest.cpp b/test/unitTest/conversation/conversationRequest.cpp index b65caef29..bb502ebc3 100644 --- a/test/unitTest/conversation/conversationRequest.cpp +++ b/test/unitTest/conversation/conversationRequest.cpp @@ -41,7 +41,7 @@ using namespace std::string_literals; using namespace std::literals::chrono_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -49,7 +49,7 @@ namespace test { class ConversationRequestTest : public CppUnit::TestFixture { public: - ~ConversationRequestTest() { DRing::fini(); } + ~ConversationRequestTest() { libjami::fini(); } static std::string name() { return "ConversationRequest"; } void setUp(); void tearDown(); @@ -109,9 +109,9 @@ void ConversationRequestTest::setUp() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); auto actors = load_actors("actors/alice-bob-carla.yml"); aliceId = actors["alice"]; @@ -145,18 +145,18 @@ ConversationRequestTest::testAcceptTrustRemoveConvReq() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; std::string convId = ""; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -165,13 +165,13 @@ ConversationRequestTest::testAcceptTrustRemoveConvReq() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 1); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 0); } @@ -186,19 +186,19 @@ ConversationRequestTest::acceptConvReqAlsoAddContact() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false, memberMessageGenerated = false; int conversationReady = 0; std::string convId = ""; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -207,7 +207,7 @@ ConversationRequestTest::acceptConvReqAlsoAddContact() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -216,17 +216,17 @@ ConversationRequestTest::acceptConvReqAlsoAddContact() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto convId2 = DRing::startConversation(aliceId); + auto convId2 = libjami::startConversation(aliceId); requestReceived = false; - DRing::addConversationMember(aliceId, convId2, bobUri); + libjami::addConversationMember(aliceId, convId2, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId2); + libjami::acceptConversationRequest(bobId, convId2); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady == 2; })); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 0); } @@ -240,27 +240,27 @@ ConversationRequestTest::testGetRequests() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto requests = DRing::getConversationRequests(bobId); + auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 1); CPPUNIT_ASSERT(requests.front()["id"] == convId); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -273,28 +273,28 @@ ConversationRequestTest::testDeclineRequest() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::declineConversationRequest(bobId, convId); + libjami::declineConversationRequest(bobId, convId); // Decline request - auto requests = DRing::getConversationRequests(bobId); + auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -307,10 +307,10 @@ ConversationRequestTest::testAddContact() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -320,7 +320,7 @@ ConversationRequestTest::testAddContact() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -329,7 +329,7 @@ ConversationRequestTest::testAddContact() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -338,7 +338,7 @@ ConversationRequestTest::testAddContact() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); @@ -371,10 +371,10 @@ ConversationRequestTest::testAddContactDeleteAndReAdd() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -384,7 +384,7 @@ ConversationRequestTest::testAddContactDeleteAndReAdd() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -393,7 +393,7 @@ ConversationRequestTest::testAddContactDeleteAndReAdd() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -402,7 +402,7 @@ ConversationRequestTest::testAddContactDeleteAndReAdd() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); @@ -435,11 +435,11 @@ ConversationRequestTest::testInviteFromMessageAfterRemoved() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string&, std::map /*metadatas*/) { @@ -447,7 +447,7 @@ ConversationRequestTest::testInviteFromMessageAfterRemoved() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -456,7 +456,7 @@ ConversationRequestTest::testInviteFromMessageAfterRemoved() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -465,7 +465,7 @@ ConversationRequestTest::testInviteFromMessageAfterRemoved() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); @@ -480,10 +480,10 @@ ConversationRequestTest::testInviteFromMessageAfterRemoved() // bob sends a message, this should generate a new request for Alice requestReceived = false; - DRing::sendMessage(aliceId, convId, "hi"s, ""); + libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); conversationReady = false; - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); } @@ -497,10 +497,10 @@ ConversationRequestTest::testRemoveContact() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -510,7 +510,7 @@ ConversationRequestTest::testRemoveContact() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -520,7 +520,7 @@ ConversationRequestTest::testRemoveContact() cv.notify_one(); })); bool conversationRemovedAlice = false, conversationRemovedBob = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == aliceId) conversationRemovedAlice = true; @@ -528,7 +528,7 @@ ConversationRequestTest::testRemoveContact() conversationRemovedBob = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -537,7 +537,7 @@ ConversationRequestTest::testRemoveContact() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files @@ -580,11 +580,11 @@ ConversationRequestTest::testRemoveSelfDoesntRemoveConversation() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, conversationRemoved = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -594,7 +594,7 @@ ConversationRequestTest::testRemoveSelfDoesntRemoveConversation() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -603,13 +603,13 @@ ConversationRequestTest::testRemoveSelfDoesntRemoveConversation() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) conversationRemoved = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -618,7 +618,7 @@ ConversationRequestTest::testRemoveSelfDoesntRemoveConversation() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files @@ -646,11 +646,11 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, conversationRemoved = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -660,7 +660,7 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -669,13 +669,13 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) conversationRemoved = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -684,7 +684,7 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files @@ -695,11 +695,11 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); conversationRemoved = false; - DRing::removeConversation(bobId, convId); + libjami::removeConversation(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); auto details = bobAccount->getContactDetails(aliceUri); - CPPUNIT_ASSERT(details[DRing::Account::TrustRequest::CONVERSATIONID] == ""); + CPPUNIT_ASSERT(details[libjami::Account::TrustRequest::CONVERSATIONID] == ""); } void @@ -712,10 +712,10 @@ ConversationRequestTest::testBanContact() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -725,7 +725,7 @@ ConversationRequestTest::testBanContact() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -734,7 +734,7 @@ ConversationRequestTest::testBanContact() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -743,7 +743,7 @@ ConversationRequestTest::testBanContact() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); @@ -772,10 +772,10 @@ ConversationRequestTest::testBanContactRemoveTrustRequest() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, requestDeclined = true; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -785,7 +785,7 @@ ConversationRequestTest::testBanContactRemoveTrustRequest() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -795,20 +795,20 @@ ConversationRequestTest::testBanContactRemoveTrustRequest() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) requestDeclined = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); bobAccount->removeContact(aliceUri, true); CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return requestDeclined; })); - auto requests = DRing::getConversationRequests(bobId); + auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); } @@ -824,10 +824,10 @@ ConversationRequestTest::testAddOfflineContactThenConnect() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -837,7 +837,7 @@ ConversationRequestTest::testAddOfflineContactThenConnect() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -846,7 +846,7 @@ ConversationRequestTest::testAddOfflineContactThenConnect() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -855,7 +855,7 @@ ConversationRequestTest::testAddOfflineContactThenConnect() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(carlaUri); aliceAccount->sendTrustRequest(carlaUri, {}); cv.wait_for(lk, 5s); // Wait 5 secs for the put to happen @@ -880,11 +880,11 @@ ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; std::string convId = ""; auto bobConnected = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -894,7 +894,7 @@ ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -903,7 +903,7 @@ ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -913,10 +913,10 @@ ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string&, const std::map&) { auto details = bobAccount->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (daemonStatus == "REGISTERED") { bobConnected = true; cv.notify_one(); @@ -925,7 +925,7 @@ ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -951,10 +951,10 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, contactAdded = false, requestReceived = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& convId, @@ -964,7 +964,7 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -973,7 +973,7 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool) { if (accountId == bobId && uri == aliceUri) { contactAdded = true; @@ -981,14 +981,14 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() cv.notify_one(); })); bool contactRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool) { if (accountId == bobId && uri == aliceUri) { contactRemoved = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -997,11 +997,11 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); - CPPUNIT_ASSERT(DRing::getConversations(bobId).size() == 1); + CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); bobAccount->removeContact(aliceUri, false); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactRemoved; })); - CPPUNIT_ASSERT(DRing::getConversations(bobId).size() == 0); + CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 0); } void @@ -1014,11 +1014,11 @@ ConversationRequestTest::testRemoveConversationRemoveSyncing() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, contactAdded = false, requestReceived = false, conversationRemoved = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& convId, @@ -1028,7 +1028,7 @@ ConversationRequestTest::testRemoveConversationRemoveSyncing() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1037,21 +1037,21 @@ ConversationRequestTest::testRemoveConversationRemoveSyncing() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) { conversationRemoved = true; } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool) { if (accountId == bobId && uri == aliceUri) { contactAdded = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -1061,11 +1061,11 @@ ConversationRequestTest::testRemoveConversationRemoveSyncing() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); // At this point the conversation should be there and syncing. - CPPUNIT_ASSERT(DRing::getConversations(bobId).size() == 1); - DRing::removeConversation(bobId, convId); + CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); + libjami::removeConversation(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); - CPPUNIT_ASSERT(DRing::getConversations(bobId).size() == 0); + CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 0); } void @@ -1078,18 +1078,18 @@ ConversationRequestTest::testCacheRequestFromClient() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false; std::string convId = ""; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1098,7 +1098,7 @@ ConversationRequestTest::testCacheRequestFromClient() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); std::vector payload = {0x64, 0x64, 0x64}; aliceAccount->sendTrustRequest(bobUri, @@ -1110,7 +1110,7 @@ ConversationRequestTest::testCacheRequestFromClient() CPPUNIT_ASSERT(fileutils::loadFile(cachedPath) == payload); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 1); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); CPPUNIT_ASSERT(!fileutils::isFile(cachedPath)); } @@ -1126,10 +1126,10 @@ ConversationRequestTest::testNeedsSyncingWithForCloning() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool contactAdded = false, requestReceived = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& convId, @@ -1139,14 +1139,14 @@ ConversationRequestTest::testNeedsSyncingWithForCloning() requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& uri, bool) { if (accountId == bobId && uri == aliceUri) { contactAdded = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); CPPUNIT_ASSERT(!bobAccount->convModule()->needsSyncingWith(aliceUri, aliceDevice)); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); @@ -1157,7 +1157,7 @@ ConversationRequestTest::testNeedsSyncingWithForCloning() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); // At this point the conversation should be there and syncing. - CPPUNIT_ASSERT(DRing::getConversations(bobId).size() == 1); + CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); CPPUNIT_ASSERT(bobAccount->convModule()->needsSyncingWith(aliceUri, aliceDevice)); } @@ -1173,12 +1173,12 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() std::condition_variable cv; // Add second device for Bob - std::map> confHandlers; + std::map> confHandlers; auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "BOB2"; details[ConfProperties::ALIAS] = "BOB2"; @@ -1196,7 +1196,7 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() conversationB2Removed = false, requestB1Received = false, requestB2Received = false, memberMessageGenerated = false; std::string convId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -1208,7 +1208,7 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() requestB2Received = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -1219,7 +1219,7 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == bobId) { conversationB1Removed = true; @@ -1228,7 +1228,7 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map message) { @@ -1237,7 +1237,7 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // First, Alice adds Bob aliceAccount->addContact(bobUri); diff --git a/test/unitTest/conversation/conversationcommon.cpp b/test/unitTest/conversation/conversationcommon.cpp index 7238b5317..8ae629346 100644 --- a/test/unitTest/conversation/conversationcommon.cpp +++ b/test/unitTest/conversation/conversationcommon.cpp @@ -114,7 +114,7 @@ simulateRemoval(std::shared_ptr account, wbuilder["indentation"] = ""; cr.commitMessage(Json::writeString(wbuilder, json)); - DRing::sendMessage(account->getAccountID(), + libjami::sendMessage(account->getAccountID(), convId, "trigger the fake history to be pulled"s, ""); diff --git a/test/unitTest/conversationRepository/conversationRepository.cpp b/test/unitTest/conversationRepository/conversationRepository.cpp index ff7c82130..a263e627e 100644 --- a/test/unitTest/conversationRepository/conversationRepository.cpp +++ b/test/unitTest/conversationRepository/conversationRepository.cpp @@ -41,7 +41,7 @@ #include using namespace std::string_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -52,11 +52,11 @@ public: ConversationRepositoryTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~ConversationRepositoryTest() { DRing::fini(); } + ~ConversationRepositoryTest() { libjami::fini(); } static std::string name() { return "ConversationRepository"; } void setUp(); void tearDown(); diff --git a/test/unitTest/fileTransfer/fileTransfer.cpp b/test/unitTest/fileTransfer/fileTransfer.cpp index fc20f3274..365aa5e9c 100644 --- a/test/unitTest/fileTransfer/fileTransfer.cpp +++ b/test/unitTest/fileTransfer/fileTransfer.cpp @@ -35,7 +35,7 @@ #include "account_const.h" #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -46,11 +46,11 @@ public: FileTransferTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~FileTransferTest() { DRing::fini(); } + ~FileTransferTest() { libjami::fini(); } static std::string name() { return "Call"; } bool compare(const std::string& fileA, const std::string& fileB) const; void setUp(); @@ -139,29 +139,29 @@ FileTransferTest::testFileTransfer() std::unique_lock lk {mtx}; std::condition_variable cv; std::condition_variable cv2; - std::map> confHandlers; + std::map> confHandlers; bool transferWaiting = false, transferFinished = false; std::string finalId; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&, const std::string&, const std::string& fileId, int code) { if (accountId == bobId - && code == static_cast(DRing::DataTransferEventCode::wait_host_acceptance)) { + && code == static_cast(libjami::DataTransferEventCode::wait_host_acceptance)) { transferWaiting = true; finalId = fileId; cv.notify_one(); } else if (accountId == aliceId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { transferFinished = true; finalId = fileId; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Create file to send auto sendVcfPath = sendPath + ".vcf"; @@ -172,20 +172,20 @@ FileTransferTest::testFileTransfer() sendFile.close(); // Send File - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; uint64_t id; info.accountId = aliceAccount->getAccountID(); info.peer = bobUri; info.path = sendVcfPath; info.displayName = "SEND.vcf"; info.bytesProgress = 0; - CPPUNIT_ASSERT(DRing::sendFileLegacy(info, id) == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::sendFileLegacy(info, id) == libjami::DataTransferError::success); cv.wait_for(lk, std::chrono::seconds(30)); CPPUNIT_ASSERT(transferWaiting); - CPPUNIT_ASSERT(DRing::acceptFileTransfer(bobId, finalId, recvVcfPath) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::acceptFileTransfer(bobId, finalId, recvVcfPath) + == libjami::DataTransferError::success); // Wait 2 times, both sides will got a finished status cv.wait_for(lk, std::chrono::seconds(30)); @@ -212,29 +212,29 @@ FileTransferTest::testDataTransferInfo() std::unique_lock lk {mtx}; std::condition_variable cv; std::condition_variable cv2; - std::map> confHandlers; + std::map> confHandlers; bool transferWaiting = false, transferFinished = false; std::string finalId; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&, const std::string&, const std::string& fileId, int code) { if (accountId == bobId - && code == static_cast(DRing::DataTransferEventCode::wait_host_acceptance)) { + && code == static_cast(libjami::DataTransferEventCode::wait_host_acceptance)) { transferWaiting = true; finalId = fileId; cv.notify_one(); } else if (accountId == aliceId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { transferFinished = true; finalId = fileId; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Create file to send std::ofstream sendFile(sendPath); @@ -243,34 +243,34 @@ FileTransferTest::testDataTransferInfo() sendFile.close(); // Send File - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; uint64_t id; info.accountId = aliceAccount->getAccountID(); info.peer = bobUri; info.path = sendPath; info.displayName = "SEND"; info.bytesProgress = 0; - CPPUNIT_ASSERT(DRing::sendFileLegacy(info, id) == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::sendFileLegacy(info, id) == libjami::DataTransferError::success); cv.wait_for(lk, std::chrono::seconds(30)); CPPUNIT_ASSERT(transferWaiting); - CPPUNIT_ASSERT(DRing::dataTransferInfo(bobId, std::to_string(id), info) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::dataTransferInfo(bobId, std::to_string(id), info) + == libjami::DataTransferError::success); - CPPUNIT_ASSERT(info.lastEvent == DRing::DataTransferEventCode::wait_host_acceptance); + CPPUNIT_ASSERT(info.lastEvent == libjami::DataTransferEventCode::wait_host_acceptance); CPPUNIT_ASSERT(info.bytesProgress == 0); CPPUNIT_ASSERT(info.totalSize == 64000); - CPPUNIT_ASSERT(DRing::dataTransferInfo(aliceId, std::to_string(id), info) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::dataTransferInfo(aliceId, std::to_string(id), info) + == libjami::DataTransferError::success); - CPPUNIT_ASSERT(info.lastEvent == DRing::DataTransferEventCode::wait_peer_acceptance); + CPPUNIT_ASSERT(info.lastEvent == libjami::DataTransferEventCode::wait_peer_acceptance); CPPUNIT_ASSERT(info.bytesProgress == 0); CPPUNIT_ASSERT(info.totalSize == 64000); - CPPUNIT_ASSERT(DRing::acceptFileTransfer(bobId, finalId, recvPath) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::acceptFileTransfer(bobId, finalId, recvPath) + == libjami::DataTransferError::success); // Wait 2 times, both sides will got a finished status cv.wait_for(lk, std::chrono::seconds(30)); @@ -279,10 +279,10 @@ FileTransferTest::testDataTransferInfo() CPPUNIT_ASSERT(compare(info.path, recvPath)); - CPPUNIT_ASSERT(DRing::dataTransferInfo(bobId, std::to_string(id), info) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::dataTransferInfo(bobId, std::to_string(id), info) + == libjami::DataTransferError::success); - CPPUNIT_ASSERT(info.lastEvent == DRing::DataTransferEventCode::finished); + CPPUNIT_ASSERT(info.lastEvent == libjami::DataTransferEventCode::finished); CPPUNIT_ASSERT(info.bytesProgress == 64000); CPPUNIT_ASSERT(info.totalSize == 64000); @@ -304,29 +304,29 @@ FileTransferTest::testMultipleFileTransfer() std::unique_lock lk {mtx}; std::condition_variable cv; std::condition_variable cv2; - std::map> confHandlers; + std::map> confHandlers; bool transferWaiting = false, transferFinished = false; std::string finalId; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&, const std::string&, const std::string& fileId, int code) { if (accountId == bobId - && code == static_cast(DRing::DataTransferEventCode::wait_host_acceptance)) { + && code == static_cast(libjami::DataTransferEventCode::wait_host_acceptance)) { transferWaiting = true; finalId = fileId; cv.notify_one(); } else if (accountId == aliceId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { transferFinished = true; finalId = fileId; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); // Create file to send std::ofstream sendFile(sendPath); @@ -340,21 +340,21 @@ FileTransferTest::testMultipleFileTransfer() sendFile2.close(); // Send first File - DRing::DataTransferInfo info; + libjami::DataTransferInfo info; uint64_t id; info.accountId = aliceAccount->getAccountID(); info.peer = bobUri; info.path = sendPath; info.displayName = "SEND"; info.bytesProgress = 0; - CPPUNIT_ASSERT(DRing::sendFileLegacy(info, id) == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::sendFileLegacy(info, id) == libjami::DataTransferError::success); cv.wait_for(lk, std::chrono::seconds(30)); CPPUNIT_ASSERT(transferWaiting); transferWaiting = false; - CPPUNIT_ASSERT(DRing::acceptFileTransfer(bobId, finalId, recvPath) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::acceptFileTransfer(bobId, finalId, recvPath) + == libjami::DataTransferError::success); // Wait 2 times, both sides will got a finished status cv.wait_for(lk, std::chrono::seconds(30)); @@ -364,19 +364,19 @@ FileTransferTest::testMultipleFileTransfer() CPPUNIT_ASSERT(compare(info.path, recvPath)); // Send File - DRing::DataTransferInfo info2; + libjami::DataTransferInfo info2; info2.accountId = aliceAccount->getAccountID(); info2.peer = bobUri; info2.path = sendPath2; info2.displayName = "SEND2"; info2.bytesProgress = 0; - CPPUNIT_ASSERT(DRing::sendFileLegacy(info2, id) == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::sendFileLegacy(info2, id) == libjami::DataTransferError::success); cv.wait_for(lk, std::chrono::seconds(30)); CPPUNIT_ASSERT(transferWaiting); - CPPUNIT_ASSERT(DRing::acceptFileTransfer(bobId, finalId, recv2Path) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::acceptFileTransfer(bobId, finalId, recv2Path) + == libjami::DataTransferError::success); // Wait 2 times, both sides will got a finished status cv.wait_for(lk, std::chrono::seconds(30)); @@ -407,7 +407,7 @@ FileTransferTest::testConversationFileTransfer() Manager::instance().sendRegister(carlaId, true); wait_for_announcement_of(carlaId); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; @@ -417,7 +417,7 @@ FileTransferTest::testConversationFileTransfer() std::string tidBob, tidCarla, iidBob, iidCarla; std::string hostAcceptanceBob = {}, hostAcceptanceCarla = {}; std::vector peerAcceptance = {}, finished = {}; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -436,7 +436,7 @@ FileTransferTest::testConversationFileTransfer() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { @@ -444,13 +444,13 @@ FileTransferTest::testConversationFileTransfer() if (requestReceived >= 2) cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */) { conversationReady += 1; if (conversationReady >= 3) cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, @@ -458,31 +458,31 @@ FileTransferTest::testConversationFileTransfer() int code) { if (conversationId.empty()) return; - if (code == static_cast(DRing::DataTransferEventCode::wait_host_acceptance)) { + if (code == static_cast(libjami::DataTransferEventCode::wait_host_acceptance)) { if (accountId == bobId) hostAcceptanceBob = fileId; else if (accountId == carlaId) hostAcceptanceCarla = fileId; cv.notify_one(); } else if (code - == static_cast(DRing::DataTransferEventCode::wait_peer_acceptance)) { + == static_cast(libjami::DataTransferEventCode::wait_peer_acceptance)) { peerAcceptance.emplace_back(fileId); cv.notify_one(); - } else if (code == static_cast(DRing::DataTransferEventCode::finished)) { + } else if (code == static_cast(libjami::DataTransferEventCode::finished)) { finished.emplace_back(fileId); cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); - DRing::addConversationMember(aliceId, convId, bobUri); - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, carlaUri); cv.wait_for(lk, std::chrono::seconds(60), [&]() { return requestReceived == 2; }); - DRing::acceptConversationRequest(bobId, convId); - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(carlaId, convId); cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady == 3 && memberJoined == 2; }); @@ -493,14 +493,14 @@ FileTransferTest::testConversationFileTransfer() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(45), [&]() { return !tidBob.empty() && !tidCarla.empty(); })); - DRing::downloadFile(bobId, convId, iidBob, tidBob, recvPath); - DRing::downloadFile(carlaId, convId, iidCarla, tidCarla, recv2Path); + libjami::downloadFile(bobId, convId, iidBob, tidBob, recvPath); + libjami::downloadFile(carlaId, convId, iidCarla, tidCarla, recv2Path); CPPUNIT_ASSERT( cv.wait_for(lk, std::chrono::seconds(45), [&]() { return finished.size() == 3; })); @@ -509,7 +509,7 @@ FileTransferTest::testConversationFileTransfer() std::remove(recvPath.c_str()); std::remove(recv2Path.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -519,17 +519,17 @@ FileTransferTest::testFileTransferInConversation() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool bobJoined = false; std::string tidBob, iidBob; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -545,14 +545,14 @@ FileTransferTest::testFileTransferInConversation() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -561,13 +561,13 @@ FileTransferTest::testFileTransferInConversation() })); bool transferAFinished = false, transferBFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { - if (code == static_cast(DRing::DataTransferEventCode::finished) + if (code == static_cast(libjami::DataTransferEventCode::finished) && conversationId == convId) { if (accountId == aliceId) transferAFinished = true; @@ -576,12 +576,12 @@ FileTransferTest::testFileTransferInConversation() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady && bobJoined; })); @@ -592,20 +592,20 @@ FileTransferTest::testFileTransferInConversation() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !tidBob.empty(); })); transferAFinished = false; transferBFinished = false; - DRing::downloadFile(bobId, convId, iidBob, tidBob, recvPath); + libjami::downloadFile(bobId, convId, iidBob, tidBob, recvPath); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferAFinished && transferBFinished; })); std::remove(sendPath.c_str()); std::remove(recvPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); std::this_thread::sleep_for(std::chrono::seconds(5)); } @@ -616,17 +616,17 @@ FileTransferTest::testVcfFileTransferInConversation() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool bobJoined = false; std::string tidBob, iidBob; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -642,14 +642,14 @@ FileTransferTest::testVcfFileTransferInConversation() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -658,13 +658,13 @@ FileTransferTest::testVcfFileTransferInConversation() })); bool transferAFinished = false, transferBFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { - if (code == static_cast(DRing::DataTransferEventCode::finished) + if (code == static_cast(libjami::DataTransferEventCode::finished) && conversationId == convId) { if (accountId == aliceId) transferAFinished = true; @@ -673,12 +673,12 @@ FileTransferTest::testVcfFileTransferInConversation() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady && bobJoined; })); @@ -689,20 +689,20 @@ FileTransferTest::testVcfFileTransferInConversation() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !tidBob.empty(); })); transferAFinished = false; transferBFinished = false; - DRing::downloadFile(bobId, convId, iidBob, tidBob, recvPath); + libjami::downloadFile(bobId, convId, iidBob, tidBob, recvPath); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferAFinished && transferBFinished; })); std::remove(sendPath.c_str()); std::remove(recvPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); std::this_thread::sleep_for(std::chrono::seconds(5)); } @@ -713,17 +713,17 @@ FileTransferTest::testBadSha3sumOut() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool memberJoin = false; std::string mid = {}, iid; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -736,14 +736,14 @@ FileTransferTest::testBadSha3sumOut() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -752,14 +752,14 @@ FileTransferTest::testBadSha3sumOut() })); bool transferAFinished = false, transferBFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { if (conversationId == convId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { if (accountId == aliceId) transferAFinished = true; if (accountId == bobId) @@ -768,7 +768,7 @@ FileTransferTest::testBadSha3sumOut() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& uri, @@ -779,12 +779,12 @@ FileTransferTest::testBadSha3sumOut() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady && memberJoin; })); @@ -795,7 +795,7 @@ FileTransferTest::testBadSha3sumOut() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !mid.empty(); })); @@ -807,7 +807,7 @@ FileTransferTest::testBadSha3sumOut() transferAFinished = false; transferBFinished = false; - DRing::downloadFile(bobId, convId, iid, mid, recvPath); + libjami::downloadFile(bobId, convId, iid, mid, recvPath); // The file transfer will not be sent as modified CPPUNIT_ASSERT(!cv.wait_for(lk, std::chrono::seconds(30), [&]() { @@ -815,7 +815,7 @@ FileTransferTest::testBadSha3sumOut() })); std::remove(sendPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -825,17 +825,17 @@ FileTransferTest::testBadSha3sumIn() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool memberJoin = false; std::string mid = {}, iid; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -848,14 +848,14 @@ FileTransferTest::testBadSha3sumIn() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -864,14 +864,14 @@ FileTransferTest::testBadSha3sumIn() })); bool transferAFinished = false, transferBFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { if (conversationId == convId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { if (accountId == aliceId) transferAFinished = true; if (accountId == bobId) @@ -880,7 +880,7 @@ FileTransferTest::testBadSha3sumIn() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& uri, @@ -891,12 +891,12 @@ FileTransferTest::testBadSha3sumIn() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&]() { return conversationReady && memberJoin; })); @@ -908,7 +908,7 @@ FileTransferTest::testBadSha3sumIn() sendFile.close(); aliceAccount->noSha3sumVerification(true); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !mid.empty(); })); // modifiy file @@ -920,14 +920,14 @@ FileTransferTest::testBadSha3sumIn() transferAFinished = false; transferBFinished = false; - DRing::downloadFile(bobId, convId, iid, mid, recvPath); + libjami::downloadFile(bobId, convId, iid, mid, recvPath); // The file transfer will be sent but refused by bob CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferAFinished; })); CPPUNIT_ASSERT(!cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferBFinished; })); std::remove(sendPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -939,17 +939,17 @@ FileTransferTest::testAskToMultipleParticipants() auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto carlaUri = carlaAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool memberJoin = false; std::string bobTid, carlaTid, iidBob, iidCarla; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -965,14 +965,14 @@ FileTransferTest::testAskToMultipleParticipants() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId || accountId == carlaId) { conversationReady = true; @@ -981,14 +981,14 @@ FileTransferTest::testAskToMultipleParticipants() })); bool transferBFinished = false, transferCFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { if (conversationId == convId - && code == static_cast(DRing::DataTransferEventCode::finished)) { + && code == static_cast(libjami::DataTransferEventCode::finished)) { if (accountId == carlaId) transferCFinished = true; if (accountId == bobId) @@ -997,7 +997,7 @@ FileTransferTest::testAskToMultipleParticipants() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& uri, @@ -1008,12 +1008,12 @@ FileTransferTest::testAskToMultipleParticipants() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&]() { return conversationReady && memberJoin; })); @@ -1022,10 +1022,10 @@ FileTransferTest::testAskToMultipleParticipants() conversationReady = false; memberJoin = false; - DRing::addConversationMember(aliceId, convId, carlaUri); + libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(carlaId, convId); + libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&]() { return conversationReady && memberJoin; })); @@ -1036,26 +1036,26 @@ FileTransferTest::testAskToMultipleParticipants() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !bobTid.empty() && !carlaTid.empty(); })); transferCFinished = false; - DRing::downloadFile(carlaId, convId, iidCarla, carlaTid, recv2Path); + libjami::downloadFile(carlaId, convId, iidCarla, carlaTid, recv2Path); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferCFinished; })); CPPUNIT_ASSERT(fileutils::isFile(recv2Path)); transferBFinished = false; - DRing::downloadFile(bobId, convId, iidBob, bobTid, recvPath); + libjami::downloadFile(bobId, convId, iidBob, bobTid, recvPath); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferBFinished; })); CPPUNIT_ASSERT(fileutils::isFile(recvPath)); std::remove(sendPath.c_str()); std::remove(recvPath.c_str()); std::remove(recv2Path.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1065,17 +1065,17 @@ FileTransferTest::testCancelInTransfer() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool bobJoined = false; std::string tidBob, iidBob; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -1091,14 +1091,14 @@ FileTransferTest::testCancelInTransfer() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -1107,29 +1107,29 @@ FileTransferTest::testCancelInTransfer() })); bool transferBOngoing = false, transferBCancelled = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { - if (code == static_cast(DRing::DataTransferEventCode::ongoing) + if (code == static_cast(libjami::DataTransferEventCode::ongoing) && conversationId == convId) { if (accountId == bobId) transferBOngoing = true; - } else if (code > static_cast(DRing::DataTransferEventCode::finished) + } else if (code > static_cast(libjami::DataTransferEventCode::finished) && conversationId == convId) { if (accountId == bobId) transferBCancelled = true; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady && bobJoined; })); @@ -1140,21 +1140,21 @@ FileTransferTest::testCancelInTransfer() sendFile << std::string(640000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !tidBob.empty(); })); transferBOngoing = false; - CPPUNIT_ASSERT(DRing::downloadFile(bobId, convId, iidBob, tidBob, recvPath)); + CPPUNIT_ASSERT(libjami::downloadFile(bobId, convId, iidBob, tidBob, recvPath)); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferBOngoing; })); transferBCancelled = false; - DRing::cancelDataTransfer(bobId, convId, tidBob); + libjami::cancelDataTransfer(bobId, convId, tidBob); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferBCancelled; })); CPPUNIT_ASSERT(!fileutils::isFile(recvPath)); CPPUNIT_ASSERT(!bobAccount->dataTransfer(convId)->isWaiting(tidBob)); std::remove(sendPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1164,17 +1164,17 @@ FileTransferTest::testTransferInfo() auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool requestReceived = false; bool conversationReady = false; bool bobJoined = false; std::string tidBob, iidBob; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map message) { @@ -1190,14 +1190,14 @@ FileTransferTest::testTransferInfo() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobId) { conversationReady = true; @@ -1206,13 +1206,13 @@ FileTransferTest::testTransferInfo() })); bool transferAFinished = false, transferBFinished = false; // Watch signals - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string&, const std::string&, int code) { - if (code == static_cast(DRing::DataTransferEventCode::finished) + if (code == static_cast(libjami::DataTransferEventCode::finished) && conversationId == convId) { if (accountId == aliceId) transferAFinished = true; @@ -1221,12 +1221,12 @@ FileTransferTest::testTransferInfo() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return conversationReady && bobJoined; })); @@ -1237,25 +1237,25 @@ FileTransferTest::testTransferInfo() sendFile << std::string(64000, 'A'); sendFile.close(); - DRing::sendFile(aliceId, convId, sendPath, "SEND", ""); + libjami::sendFile(aliceId, convId, sendPath, "SEND", ""); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return !tidBob.empty(); })); int64_t totalSize, bytesProgress; std::string path; - CPPUNIT_ASSERT(DRing::fileTransferInfo(bobId, convId, tidBob, path, totalSize, bytesProgress) - == DRing::DataTransferError::invalid_argument); + CPPUNIT_ASSERT(libjami::fileTransferInfo(bobId, convId, tidBob, path, totalSize, bytesProgress) + == libjami::DataTransferError::invalid_argument); CPPUNIT_ASSERT(bytesProgress == 0); CPPUNIT_ASSERT(!fileutils::isFile(path)); // No check for total as not started transferAFinished = false; transferBFinished = false; - DRing::downloadFile(bobId, convId, iidBob, tidBob, recvPath); + libjami::downloadFile(bobId, convId, iidBob, tidBob, recvPath); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(30), [&]() { return transferAFinished && transferBFinished; })); - CPPUNIT_ASSERT(DRing::fileTransferInfo(bobId, convId, tidBob, path, totalSize, bytesProgress) - == DRing::DataTransferError::success); + CPPUNIT_ASSERT(libjami::fileTransferInfo(bobId, convId, tidBob, path, totalSize, bytesProgress) + == libjami::DataTransferError::success); CPPUNIT_ASSERT(bytesProgress == 64000); CPPUNIT_ASSERT(totalSize == 64000); @@ -1263,7 +1263,7 @@ FileTransferTest::testTransferInfo() std::remove(sendPath.c_str()); std::remove(recvPath.c_str()); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); std::this_thread::sleep_for(std::chrono::seconds(5)); } diff --git a/test/unitTest/ice/ice.cpp b/test/unitTest/ice/ice.cpp index 31dfa4aab..a64c51e07 100644 --- a/test/unitTest/ice/ice.cpp +++ b/test/unitTest/ice/ice.cpp @@ -30,7 +30,7 @@ #include "jami.h" #include "account_const.h" -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -41,11 +41,11 @@ public: IceTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~IceTest() { DRing::fini(); } + ~IceTest() { libjami::fini(); } static std::string name() { return "Ice"; } void setUp(); void tearDown(); diff --git a/test/unitTest/ice/ice_media_cand_exchange.cpp b/test/unitTest/ice/ice_media_cand_exchange.cpp index e490192c9..885ac62e1 100644 --- a/test/unitTest/ice/ice_media_cand_exchange.cpp +++ b/test/unitTest/ice/ice_media_cand_exchange.cpp @@ -39,8 +39,8 @@ #include "common.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -81,11 +81,11 @@ public: IceMediaCandExchangeTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~IceMediaCandExchangeTest() { DRing::fini(); } + ~IceMediaCandExchangeTest() { libjami::fini(); } static std::string name() { return "IceMediaCandExchangeTest"; } void setUp(); @@ -115,7 +115,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, const std::string& event, @@ -184,13 +184,13 @@ IceMediaCandExchangeTest::getUserAlias(const std::string& callId) void IceMediaCandExchangeTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -204,7 +204,7 @@ IceMediaCandExchangeTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; callData.signals_.emplace_back( - CallData::Signal(callId, DRing::CallSignal::IncomingCallWithMedia::name)); + CallData::Signal(callId, libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -216,14 +216,14 @@ IceMediaCandExchangeTest::onCallStateChange(const std::string&, CallData& callData) { JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(callId, DRing::CallSignal::StateChange::name, state)); + CallData::Signal(callId, libjami::CallSignal::StateChange::name, state)); } if (state == "RINGING" or state == "CURRENT" or state == "HUNGUP" or state == "OVER") { @@ -249,7 +249,7 @@ IceMediaCandExchangeTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -260,7 +260,7 @@ IceMediaCandExchangeTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(callId, DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(callId, libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -327,7 +327,7 @@ IceMediaCandExchangeTest::setupJamiAccount(CallData& user) // Apply the settings according to the test case details[ConfProperties::UPNP_ENABLED] = user.upnpEnabled_ ? "true" : "false"; details[ConfProperties::TURN::ENABLED] = user.turnEnabled_ ? "true" : "false"; - DRing::setAccountDetails(user.accountId_, details); + libjami::setAccountDetails(user.accountId_, details); } void @@ -335,8 +335,8 @@ IceMediaCandExchangeTest::setupSipAccount(CallData& user) { CPPUNIT_ASSERT_GREATER(0, static_cast(user.listeningPort_)); - auto details = DRing::getAccountTemplate(DRing::Account::ProtocolNames::SIP); - details[ConfProperties::TYPE] = DRing::Account::ProtocolNames::SIP; + auto details = libjami::getAccountTemplate(libjami::Account::ProtocolNames::SIP); + details[ConfProperties::TYPE] = libjami::Account::ProtocolNames::SIP; details[ConfProperties::DISPLAYNAME] = user.displayName_.c_str(); details[ConfProperties::ALIAS] = user.displayName_.c_str(); details[ConfProperties::LOCAL_PORT] = std::to_string(user.listeningPort_); @@ -367,7 +367,7 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, CallData& bobData, const char* accountType) { - if (strcmp(accountType, DRing::Account::ProtocolNames::SIP) == 0) { + if (strcmp(accountType, libjami::Account::ProtocolNames::SIP) == 0) { JAMI_INFO("Setup SIP accounts and configure test case ..."); aliceData.displayName_ = "ALICE"; @@ -394,13 +394,13 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, } // Setup signal handlers. - std::map> signalHandlers; + std::map> signalHandlers; - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (user.empty()) { // The call was probably already removed, in this case, just @@ -423,7 +423,7 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -448,7 +448,7 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, } })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>& /* mediaList */) { @@ -472,7 +472,7 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, })); signalHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map&) { auto account = Manager::instance().getAccount(accountId); if (not account) { @@ -481,7 +481,7 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, } auto details = account->getVolatileAccountDetails(); - auto daemonStatus = details[DRing::Account::ConfProperties::Registration::STATUS]; + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; if (accountId == aliceData.accountId_) { aliceData.accountRegistered_ = daemonStatus == "REGISTERED"; @@ -494,14 +494,14 @@ IceMediaCandExchangeTest::setupAccounts(CallData& aliceData, } })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void IceMediaCandExchangeTest::configureAccount(CallData& user, const char* accountType) { auto details - = strcmp(accountType, DRing::Account::ProtocolNames::RING) == 0 + = strcmp(accountType, libjami::Account::ProtocolNames::RING) == 0 ? Manager::instance().getAccount(user.accountId_)->getAccountDetails() : Manager::instance().getAccount(user.accountId_)->getAccountDetails(); @@ -509,13 +509,13 @@ IceMediaCandExchangeTest::configureAccount(CallData& user, const char* accountTy details[ConfProperties::UPNP_ENABLED] = user.upnpEnabled_ ? "true" : "false"; details[ConfProperties::TURN::ENABLED] = user.turnEnabled_ ? "true" : "false"; - DRing::setAccountDetails(user.accountId_, details); + libjami::setAccountDetails(user.accountId_, details); // Note: setAccountDetails will trigger a re-register of the account, so // we need to wait for the registration to proceed. // Only done for JAMI accounts. - if (strcmp(accountType, DRing::Account::ProtocolNames::RING) != 0) + if (strcmp(accountType, libjami::Account::ProtocolNames::RING) != 0) return; auto account = Manager::instance().getAccount(user.accountId_); @@ -564,7 +564,7 @@ IceMediaCandExchangeTest::validate_ice_candidates(CallData& user, // candidates are only added if UPNP is enabled and the mapping is // successful. int expectedSrflxCandCount = 0; - if (strcmp(accountType, DRing::Account::ProtocolNames::RING) == 0) { + if (strcmp(accountType, libjami::Account::ProtocolNames::RING) == 0) { if (hasUpnp) { if (upnpSameAsPublished) { // UPNP and published are the same, published wont be added. @@ -616,13 +616,13 @@ IceMediaCandExchangeTest::test_call(const char* accountType) CPPUNIT_ASSERT_EQUAL(MEDIA_COUNT, answer.size()); // Set the destination according to account type. - auto dest = strcmp(accountType, DRing::Account::ProtocolNames::SIP) == 0 + auto dest = strcmp(accountType, libjami::Account::ProtocolNames::SIP) == 0 ? bobData_.dest_.toString(true) : bobData_.userName_; CPPUNIT_ASSERT(not dest.empty()); - aliceData_.callId_ = DRing::placeCallWithMedia(aliceData_.accountId_, + aliceData_.callId_ = libjami::placeCallWithMedia(aliceData_.accountId_, dest, MediaAttribute::mediaAttributesToMediaMaps( offer)); @@ -638,31 +638,31 @@ IceMediaCandExchangeTest::test_call(const char* accountType) // Wait for call to be processed. CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::RINGING)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData_, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData_, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(bobData_.accountId_, + libjami::acceptWithMedia(bobData_.accountId_, bobData_.callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(bobData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT( - waitForSignal(bobData_, DRing::CallSignal::StateChange::name, StateEvent::CURRENT)); + waitForSignal(bobData_, libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData_.callId_.c_str()); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(aliceData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate ICE candidates validate_ice_candidates(aliceData_, accountType, hasUpnp_, upnpAddrSameAsPublished_); @@ -676,15 +676,15 @@ IceMediaCandExchangeTest::test_call(const char* accountType) Manager::instance().hangupCall(bobData_.accountId_, bobData_.callId_); CPPUNIT_ASSERT( - waitForSignal(bobData_, DRing::CallSignal::StateChange::name, StateEvent::HUNGUP)); + waitForSignal(bobData_, libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::HUNGUP)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); - CPPUNIT_ASSERT(waitForSignal(bobData_, DRing::CallSignal::StateChange::name, StateEvent::OVER)); + CPPUNIT_ASSERT(waitForSignal(bobData_, libjami::CallSignal::StateChange::name, StateEvent::OVER)); CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::OVER)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::OVER)); JAMI_INFO("Call terminated on both sides"); @@ -698,7 +698,7 @@ IceMediaCandExchangeTest::test_call(const char* accountType) void IceMediaCandExchangeTest::check_upnp() { - auto accountType = DRing::Account::ProtocolNames::RING; + auto accountType = libjami::Account::ProtocolNames::RING; setupAccounts(aliceData_, bobData_, accountType); auto const& account = Manager::instance().getAccount(aliceData_.accountId_); auto publishedAddr = account->getPublishedIpAddress(AF_INET); @@ -750,7 +750,7 @@ IceMediaCandExchangeTest::jami_account_no_turn() { JAMI_INFO("=== Begin test %s ===", __FUNCTION__); - auto accountType = DRing::Account::ProtocolNames::RING; + auto accountType = libjami::Account::ProtocolNames::RING; setupAccounts(aliceData_, bobData_, accountType); bobData_.turnEnabled_ = false; @@ -794,7 +794,7 @@ IceMediaCandExchangeTest::jami_account_with_turn() { JAMI_INFO("=== Begin test %s ===", __FUNCTION__); - auto accountType = DRing::Account::ProtocolNames::RING; + auto accountType = libjami::Account::ProtocolNames::RING; setupAccounts(aliceData_, bobData_, accountType); bobData_.turnEnabled_ = true; diff --git a/test/unitTest/ice/ice_sdp_parser.cpp b/test/unitTest/ice/ice_sdp_parser.cpp index da06ab40d..bc9be6292 100644 --- a/test/unitTest/ice/ice_sdp_parser.cpp +++ b/test/unitTest/ice/ice_sdp_parser.cpp @@ -39,8 +39,8 @@ #include "common.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -123,15 +123,15 @@ public: IceSdpParsingTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); for (size_t idx = 0; idx < MEDIA_COUNT; idx++) { mediaReceivers_.emplace_back(std::make_shared(MediaType::MEDIA_AUDIO)); } } - ~IceSdpParsingTest() { DRing::fini(); } + ~IceSdpParsingTest() { libjami::fini(); } static std::string name() { return "IceSdpParsingTest"; } void setUp(); @@ -154,7 +154,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, const std::string& event, @@ -187,7 +187,7 @@ void IceSdpParsingTest::setUp() { aliceData_.listeningPort_ = 5080; - std::map details = DRing::getAccountTemplate("SIP"); + std::map details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "ALICE"; details[ConfProperties::ALIAS] = "ALICE"; @@ -196,7 +196,7 @@ IceSdpParsingTest::setUp() aliceData_.accountId_ = Manager::instance().addAccount(details); bobData_.listeningPort_ = 5082; - details = DRing::getAccountTemplate("SIP"); + details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "BOB"; details[ConfProperties::ALIAS] = "BOB"; @@ -237,13 +237,13 @@ IceSdpParsingTest::getUserAlias(const std::string& callId) void IceSdpParsingTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -261,7 +261,7 @@ IceSdpParsingTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -285,7 +285,7 @@ IceSdpParsingTest::onCallStateChange(const std::string&, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -296,7 +296,7 @@ IceSdpParsingTest::onCallStateChange(const std::string&, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } if (state == "CURRENT" or state == "OVER" or state == "HUNGUP") { @@ -322,7 +322,7 @@ IceSdpParsingTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -333,7 +333,7 @@ IceSdpParsingTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -452,14 +452,14 @@ IceSdpParsingTest::configureTest(CallData& aliceData, CallData& bobData) account->enableIceCompIdRfc5245Compliance(bobData.compliancyEnabled_); } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onIncomingCallWithMedia(accountId, @@ -469,7 +469,7 @@ IceSdpParsingTest::configureTest(CallData& aliceData, CallData& bobData) })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -481,7 +481,7 @@ IceSdpParsingTest::configureTest(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>& /* mediaList */) { @@ -492,7 +492,7 @@ IceSdpParsingTest::configureTest(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -530,7 +530,7 @@ IceSdpParsingTest::test_call() auto bobAddr = ip_utils::getLocalAddr(AF_INET); bobAddr.setPort(bobData_.listeningPort_); - aliceData_.callId_ = DRing::placeCallWithMedia(aliceData_.accountId_, + aliceData_.callId_ = libjami::placeCallWithMedia(aliceData_.accountId_, bobAddr.toString(true), MediaAttribute::mediaAttributesToMediaMaps( offer)); @@ -545,31 +545,31 @@ IceSdpParsingTest::test_call() // Wait for call to be processed. CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::RINGING)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData_, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData_, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(bobData_.accountId_, + libjami::acceptWithMedia(bobData_.accountId_, bobData_.callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(bobData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT( - waitForSignal(bobData_, DRing::CallSignal::StateChange::name, StateEvent::CURRENT)); + waitForSignal(bobData_, libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData_.callId_.c_str()); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(aliceData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Give some time to media to start. std::this_thread::sleep_for(std::chrono::seconds(2)); @@ -611,12 +611,12 @@ IceSdpParsingTest::test_call() CPPUNIT_ASSERT_EQUAL(true, waitForSignal(aliceData_, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); CPPUNIT_ASSERT_EQUAL(true, waitForSignal(bobData_, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); diff --git a/test/unitTest/media/audio/test_resampler.cpp b/test/unitTest/media/audio/test_resampler.cpp index 63d6cc80b..28ce52618 100644 --- a/test/unitTest/media/audio/test_resampler.cpp +++ b/test/unitTest/media/audio/test_resampler.cpp @@ -57,13 +57,13 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ResamplerTest, ResamplerTest::name()); void ResamplerTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); } void ResamplerTest::tearDown() { - DRing::fini(); + libjami::fini(); } void @@ -94,7 +94,7 @@ ResamplerTest::testAudioFrame() CPPUNIT_ASSERT(input->pointer()->data && input->pointer()->data[0]); CPPUNIT_ASSERT(input->pointer()->data[0][0] == 0); - DRing::AudioFrame out; + libjami::AudioFrame out; auto output = out.pointer(); output->format = AV_SAMPLE_FMT_FLT; output->sample_rate = 48000; @@ -114,17 +114,17 @@ ResamplerTest::testRematrix() const constexpr AudioFormat inFormat = AudioFormat(44100, 6); resampler_.reset(new Resampler); - auto input = std::make_unique(inFormat, 882); + auto input = std::make_unique(inFormat, 882); CPPUNIT_ASSERT(input->pointer() && input->pointer()->data); - auto output1 = std::make_unique(AudioFormat::STEREO(), 960); + auto output1 = std::make_unique(AudioFormat::STEREO(), 960); CPPUNIT_ASSERT(output1->pointer() && output1->pointer()->data); ret = resampler_->resample(input->pointer(), output1->pointer()); CPPUNIT_ASSERT_MESSAGE(libav_utils::getError(ret).c_str(), ret >= 0); CPPUNIT_ASSERT(output1->pointer()->data && output1->pointer()->data[0]); - auto output2 = std::make_unique(AudioFormat::MONO(), 960); + auto output2 = std::make_unique(AudioFormat::MONO(), 960); CPPUNIT_ASSERT(output2->pointer() && output2->pointer()->data); ret = resampler_->resample(input->pointer(), output2->pointer()); diff --git a/test/unitTest/media/test_media_decoder.cpp b/test/unitTest/media/test_media_decoder.cpp index 00a7c9458..661017418 100644 --- a/test/unitTest/media/test_media_decoder.cpp +++ b/test/unitTest/media/test_media_decoder.cpp @@ -59,7 +59,7 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(MediaDecoderTest, MediaDecoderTest::name() void MediaDecoderTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); libav_utils::av_init(); } @@ -67,7 +67,7 @@ void MediaDecoderTest::tearDown() { fileutils::remove(filename_); - DRing::fini(); + libjami::fini(); } void diff --git a/test/unitTest/media/test_media_encoder.cpp b/test/unitTest/media/test_media_encoder.cpp index 1b99898e7..787d622e8 100644 --- a/test/unitTest/media/test_media_encoder.cpp +++ b/test/unitTest/media/test_media_encoder.cpp @@ -56,7 +56,7 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(MediaEncoderTest, MediaEncoderTest::name() void MediaEncoderTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); libav_utils::av_init(); encoder_.reset(new MediaEncoder); files_.push_back("test.mkv"); @@ -68,7 +68,7 @@ MediaEncoderTest::tearDown() // clean up behind ourselves for (const auto& file : files_) fileutils::remove(file); - DRing::fini(); + libjami::fini(); } static AVFrame* diff --git a/test/unitTest/media/test_media_filter.cpp b/test/unitTest/media/test_media_filter.cpp index 8888d2e1d..6e7919241 100644 --- a/test/unitTest/media/test_media_filter.cpp +++ b/test/unitTest/media/test_media_filter.cpp @@ -61,7 +61,7 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(MediaFilterTest, MediaFilterTest::name()); void MediaFilterTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); libav_utils::av_init(); filter_.reset(new MediaFilter); } @@ -69,7 +69,7 @@ MediaFilterTest::setUp() void MediaFilterTest::tearDown() { - DRing::fini(); + libjami::fini(); } static void diff --git a/test/unitTest/media/test_media_frame.cpp b/test/unitTest/media/test_media_frame.cpp index bd78bb509..aef9afa7c 100644 --- a/test/unitTest/media/test_media_frame.cpp +++ b/test/unitTest/media/test_media_frame.cpp @@ -58,26 +58,26 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(MediaFrameTest, MediaFrameTest::name()); void MediaFrameTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); } void MediaFrameTest::tearDown() { - DRing::fini(); + libjami::fini(); } void MediaFrameTest::testCopy() { // test allocation - DRing::VideoFrame v1; + libjami::VideoFrame v1; v1.reserve(AV_PIX_FMT_YUV420P, 100, 100); v1.pointer()->data[0][0] = 42; CPPUNIT_ASSERT(v1.pointer()); // test frame referencing (different pointers, but same data) - DRing::VideoFrame v2; + libjami::VideoFrame v2; v2.copyFrom(v1); CPPUNIT_ASSERT(v1.format() == v2.format()); CPPUNIT_ASSERT(v1.width() == v2.width()); @@ -92,7 +92,7 @@ MediaFrameTest::testMix() { const AudioFormat& format = AudioFormat::STEREO(); const int nbSamples = format.sample_rate / 50; - auto a1 = std::make_unique(format, nbSamples); + auto a1 = std::make_unique(format, nbSamples); auto d1 = reinterpret_cast(a1->pointer()->extended_data[0]); d1[0] = 0; d1[1] = 1; @@ -101,7 +101,7 @@ MediaFrameTest::testMix() d1[4] = 5; d1[5] = std::numeric_limits::min(); d1[6] = std::numeric_limits::max(); - auto a2 = std::make_unique(format, nbSamples); + auto a2 = std::make_unique(format, nbSamples); auto d2 = reinterpret_cast(a2->pointer()->extended_data[0]); d2[0] = 0; d2[1] = 3; diff --git a/test/unitTest/media/video/testVideo_input.cpp b/test/unitTest/media/video/testVideo_input.cpp index 32b396bc2..5fe077fa6 100644 --- a/test/unitTest/media/video/testVideo_input.cpp +++ b/test/unitTest/media/video/testVideo_input.cpp @@ -43,11 +43,11 @@ public: VideoInputTest() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); - DRing::start("jami-sample.yml"); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); + libjami::start("jami-sample.yml"); } - ~VideoInputTest() { DRing::fini(); } + ~VideoInputTest() { libjami::fini(); } private: void testInput(); @@ -62,11 +62,11 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VideoInputTest, VideoInputTest::name()); void VideoInputTest::testInput() { - static const std::string sep = DRing::Media::VideoProtocolPrefix::SEPARATOR; - std::string resource = DRing::Media::VideoProtocolPrefix::DISPLAY + sep + static const std::string sep = libjami::Media::VideoProtocolPrefix::SEPARATOR; + std::string resource = libjami::Media::VideoProtocolPrefix::DISPLAY + sep + std::string(getenv("DISPLAY") ?: ":0.0"); video::VideoInput video; - DRing::switchInput("", "", resource); + libjami::switchInput("", "", resource); } } // namespace test diff --git a/test/unitTest/media/video/test_video_scaler.cpp b/test/unitTest/media/video/test_video_scaler.cpp index fbc3ea609..41cf6d6d4 100644 --- a/test/unitTest/media/video/test_video_scaler.cpp +++ b/test/unitTest/media/video/test_video_scaler.cpp @@ -57,13 +57,13 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VideoScalerTest, VideoScalerTest::name()); void VideoScalerTest::setUp() { - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); } void VideoScalerTest::tearDown() { - DRing::fini(); + libjami::fini(); } void @@ -71,7 +71,7 @@ VideoScalerTest::testConvertFrame() { scaler_.reset(new VideoScaler); - DRing::VideoFrame input; + libjami::VideoFrame input; input.reserve(AV_PIX_FMT_YUV420P, 100, 100); auto output = scaler_->convertFormat(input, AV_PIX_FMT_RGB24); CPPUNIT_ASSERT(static_cast(output->format()) == AV_PIX_FMT_RGB24); @@ -82,7 +82,7 @@ VideoScalerTest::testScale() { scaler_.reset(new VideoScaler); - DRing::VideoFrame input, output; + libjami::VideoFrame input, output; input.reserve(AV_PIX_FMT_YUV420P, 100, 100); output.reserve(AV_PIX_FMT_YUV420P, 200, 200); scaler_->scale(input, output); @@ -96,7 +96,7 @@ VideoScalerTest::testScaleWithAspect() { scaler_.reset(new VideoScaler); - DRing::VideoFrame input, output; + libjami::VideoFrame input, output; input.reserve(AV_PIX_FMT_YUV420P, 320, 240); // 4:3 output.reserve(AV_PIX_FMT_YUV420P, 640, 360); // 16:9 scaler_->scale_with_aspect(input, output); diff --git a/test/unitTest/media_negotiation/auto_answer.cpp b/test/unitTest/media_negotiation/auto_answer.cpp index 0501bfcbb..a706ce2f1 100644 --- a/test/unitTest/media_negotiation/auto_answer.cpp +++ b/test/unitTest/media_negotiation/auto_answer.cpp @@ -39,8 +39,8 @@ #include "common.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -96,11 +96,11 @@ public: AutoAnswerMediaNegoTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~AutoAnswerMediaNegoTest() { DRing::fini(); } + ~AutoAnswerMediaNegoTest() { libjami::fini(); } protected: // Test cases. @@ -116,11 +116,11 @@ protected: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onVideoMuted(const std::string& callId, bool muted, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, @@ -177,7 +177,7 @@ void AutoAnswerMediaNegoTestSip::setUp() { aliceData_.listeningPort_ = 5080; - std::map details = DRing::getAccountTemplate("SIP"); + std::map details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "ALICE"; details[ConfProperties::ALIAS] = "ALICE"; @@ -186,7 +186,7 @@ AutoAnswerMediaNegoTestSip::setUp() aliceData_.accountId_ = Manager::instance().addAccount(details); bobData_.listeningPort_ = 5082; - details = DRing::getAccountTemplate("SIP"); + details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "BOB"; details[ConfProperties::ALIAS] = "BOB"; @@ -205,27 +205,27 @@ AutoAnswerMediaNegoTestSip::tearDown() { JAMI_INFO("Remove created accounts..."); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; auto currentAccSize = Manager::instance().getAccountList().size(); std::atomic_bool accountsRemoved {false}; confHandlers.insert( - DRing::exportable_callback([&]() { + libjami::exportable_callback([&]() { if (Manager::instance().getAccountList().size() <= currentAccSize - 2) { accountsRemoved = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().removeAccount(aliceData_.accountId_, true); Manager::instance().removeAccount(bobData_.accountId_, true); CPPUNIT_ASSERT( cv.wait_for(lk, std::chrono::seconds(30), [&] { return accountsRemoved.load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } class AutoAnswerMediaNegoTestJami : public AutoAnswerMediaNegoTest, public CppUnit::TestFixture @@ -381,13 +381,13 @@ AutoAnswerMediaNegoTest::validateMediaDirection(std::vector de void AutoAnswerMediaNegoTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -400,7 +400,7 @@ AutoAnswerMediaNegoTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -408,13 +408,13 @@ AutoAnswerMediaNegoTest::onIncomingCallWithMedia(const std::string& accountId, void AutoAnswerMediaNegoTest::onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::MediaChangeRequested::name, + libjami::CallSignal::MediaChangeRequested::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -427,7 +427,7 @@ AutoAnswerMediaNegoTest::onMediaChangeRequested(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::MediaChangeRequested::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::MediaChangeRequested::name)); callData.cv_.notify_one(); } @@ -453,7 +453,7 @@ AutoAnswerMediaNegoTest::onCallStateChange(const std::string& accountId UNUSED, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -464,7 +464,7 @@ AutoAnswerMediaNegoTest::onCallStateChange(const std::string& accountId UNUSED, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } if (state == "CURRENT" or state == "OVER" or state == "HUNGUP") { @@ -489,7 +489,7 @@ AutoAnswerMediaNegoTest::onVideoMuted(const std::string& callId, bool muted, Cal } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::VideoMuted::name, + libjami::CallSignal::VideoMuted::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), muted ? "Mute" : "Un-mute"); @@ -500,7 +500,7 @@ AutoAnswerMediaNegoTest::onVideoMuted(const std::string& callId, bool muted, Cal { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::VideoMuted::name, muted ? "muted" : "un-muted")); + CallData::Signal(libjami::CallSignal::VideoMuted::name, muted ? "muted" : "un-muted")); } callData.cv_.notify_one(); @@ -524,7 +524,7 @@ AutoAnswerMediaNegoTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -535,7 +535,7 @@ AutoAnswerMediaNegoTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -624,14 +624,14 @@ AutoAnswerMediaNegoTest::configureScenario() } } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onIncomingCallWithMedia(accountId, @@ -640,10 +640,10 @@ AutoAnswerMediaNegoTest::configureScenario() user == aliceData_.alias_ ? aliceData_ : bobData_); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onMediaChangeRequested(accountId, @@ -653,7 +653,7 @@ AutoAnswerMediaNegoTest::configureScenario() })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -665,14 +665,14 @@ AutoAnswerMediaNegoTest::configureScenario() user == aliceData_.alias_ ? aliceData_ : bobData_); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, bool muted) { auto user = getUserAlias(callId); if (not user.empty()) onVideoMuted(callId, muted, user == aliceData_.alias_ ? aliceData_ : bobData_); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>&) { @@ -683,7 +683,7 @@ AutoAnswerMediaNegoTest::configureScenario() user == aliceData_.alias_ ? aliceData_ : bobData_); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -697,7 +697,7 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, auto mediaCount = scenario.offer_.size(); CPPUNIT_ASSERT_EQUAL(mediaCount, scenario.answer_.size()); - aliceData.callId_ = DRing::placeCallWithMedia(aliceData.accountId_, + aliceData.callId_ = libjami::placeCallWithMedia(aliceData.accountId_, isSipAccount_ ? bobData.toUri_ : bobData_.userName_, MediaAttribute::mediaAttributesToMediaMaps( @@ -713,7 +713,7 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, bobData.accountId_.c_str()); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData, libjami::CallSignal::IncomingCallWithMedia::name)); // Bob automatically answers the call. @@ -721,12 +721,12 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(bobData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT_EQUAL(true, waitForSignal(bobData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData.callId_.c_str()); @@ -735,8 +735,8 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { @@ -783,7 +783,7 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, JAMI_INFO("=== Request Media Change and validate ==="); { auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.offerUpdate_); - DRing::requestMediaChange(aliceData.accountId_, aliceData.callId_, mediaList); + libjami::requestMediaChange(aliceData.accountId_, aliceData.callId_, mediaList); } // Update and validate media count. @@ -795,8 +795,8 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { @@ -845,11 +845,11 @@ AutoAnswerMediaNegoTest::testWithScenario(CallData& aliceData, // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(bobData.accountId_, bobData.callId_); + libjami::hangUp(bobData.accountId_, bobData.callId_); CPPUNIT_ASSERT_EQUAL(true, waitForSignal(aliceData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); @@ -892,7 +892,7 @@ AutoAnswerMediaNegoTest::audio_and_video_then_caller_mute_video() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -928,7 +928,7 @@ AutoAnswerMediaNegoTest::audio_only_then_caller_add_video() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -971,7 +971,7 @@ AutoAnswerMediaNegoTest::audio_and_video_then_caller_mute_audio() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1015,7 +1015,7 @@ AutoAnswerMediaNegoTest::audio_and_video_then_change_video_source() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } diff --git a/test/unitTest/media_negotiation/hold_resume.cpp b/test/unitTest/media_negotiation/hold_resume.cpp index 6111a2e83..398f547b1 100644 --- a/test/unitTest/media_negotiation/hold_resume.cpp +++ b/test/unitTest/media_negotiation/hold_resume.cpp @@ -37,8 +37,8 @@ #include "common.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -95,11 +95,11 @@ public: HoldResumeTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~HoldResumeTest() { DRing::fini(); } + ~HoldResumeTest() { libjami::fini(); } static std::string name() { return "HoldResumeTest"; } void setUp(); @@ -121,7 +121,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); // For backward compatibility test cases static void onIncomingCall(const std::string& accountId, @@ -129,7 +129,7 @@ private: CallData& callData); static void onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, const std::string& event, @@ -194,13 +194,13 @@ HoldResumeTest::getUserAlias(const std::string& callId) void HoldResumeTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -213,7 +213,7 @@ HoldResumeTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -226,7 +226,7 @@ HoldResumeTest::onIncomingCall(const std::string& accountId, CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s]", - DRing::CallSignal::IncomingCall::name, + libjami::CallSignal::IncomingCall::name, callData.alias_.c_str(), callId.c_str()); @@ -238,7 +238,7 @@ HoldResumeTest::onIncomingCall(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCall::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCall::name)); callData.cv_.notify_one(); } @@ -246,13 +246,13 @@ HoldResumeTest::onIncomingCall(const std::string& accountId, void HoldResumeTest::onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::MediaChangeRequested::name, + libjami::CallSignal::MediaChangeRequested::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -265,7 +265,7 @@ HoldResumeTest::onMediaChangeRequested(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::MediaChangeRequested::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::MediaChangeRequested::name)); callData.cv_.notify_one(); } @@ -288,7 +288,7 @@ HoldResumeTest::onCallStateChange(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -299,7 +299,7 @@ HoldResumeTest::onCallStateChange(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } if (state == "CURRENT" or state == "OVER" or state == "HUNGUP") { @@ -325,7 +325,7 @@ HoldResumeTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -336,7 +336,7 @@ HoldResumeTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -408,14 +408,14 @@ HoldResumeTest::configureScenario(CallData& aliceData, CallData& bobData) bobData.alias_ = account->getAccountDetails()[ConfProperties::ALIAS]; } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onIncomingCallWithMedia(accountId, @@ -424,7 +424,7 @@ HoldResumeTest::configureScenario(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&) { auto user = getUserAlias(callId); if (not user.empty()) { @@ -432,10 +432,10 @@ HoldResumeTest::configureScenario(CallData& aliceData, CallData& bobData) } })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onMediaChangeRequested(accountId, @@ -444,14 +444,14 @@ HoldResumeTest::configureScenario(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string&, const std::string& callId, const std::string& state, signed) { auto user = getUserAlias(callId); if (not user.empty()) onCallStateChange(callId, state, user == aliceData.alias_ ? aliceData : bobData); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>&) { @@ -462,7 +462,7 @@ HoldResumeTest::configureScenario(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -488,7 +488,7 @@ HoldResumeTest::testWithScenario(CallData& aliceData, bobData.accountId_.c_str()); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. { @@ -500,12 +500,12 @@ HoldResumeTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(bobData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT_EQUAL(true, waitForSignal(bobData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData.callId_.c_str()); @@ -514,8 +514,8 @@ HoldResumeTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media and SDP { @@ -556,7 +556,7 @@ HoldResumeTest::testWithScenario(CallData& aliceData, JAMI_INFO("=== Hold the call and validate ==="); { auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.offerUpdate_); - DRing::hold(aliceData.accountId_, aliceData.callId_); + libjami::hold(aliceData.accountId_, aliceData.callId_); } // Update and validate media count. @@ -568,8 +568,8 @@ HoldResumeTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { @@ -605,7 +605,7 @@ HoldResumeTest::testWithScenario(CallData& aliceData, JAMI_INFO("=== Resume the call and validate ==="); { auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.offerUpdate_); - DRing::unhold(aliceData.accountId_, aliceData.callId_); + libjami::unhold(aliceData.accountId_, aliceData.callId_); } // Update and validate media count. @@ -617,8 +617,8 @@ HoldResumeTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { auto mediaAttr = aliceCall->getMediaAttributeList(); @@ -656,7 +656,7 @@ HoldResumeTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL(true, waitForSignal(aliceData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); @@ -697,7 +697,7 @@ HoldResumeTest::audio_and_video_then_hold_resume() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -727,7 +727,7 @@ HoldResumeTest::audio_only_then_hold_resume() testWithScenario(aliceData_, bobData_, scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } diff --git a/test/unitTest/media_negotiation/media_negotiation.cpp b/test/unitTest/media_negotiation/media_negotiation.cpp index 4483fcbeb..098bf1e6b 100644 --- a/test/unitTest/media_negotiation/media_negotiation.cpp +++ b/test/unitTest/media_negotiation/media_negotiation.cpp @@ -38,8 +38,8 @@ #include "common.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -112,11 +112,11 @@ public: MediaNegotiationTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~MediaNegotiationTest() { DRing::fini(); } + ~MediaNegotiationTest() { libjami::fini(); } static std::string name() { return "MediaNegotiationTest"; } @@ -136,7 +136,7 @@ protected: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); // For backward compatibility test cases. // TODO. Do we still need this? @@ -145,7 +145,7 @@ protected: CallData& callData); static void onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onVideoMuted(const std::string& callId, bool muted, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, @@ -232,7 +232,7 @@ public: callData.alias_ = alias; callData.userName_ = alias; callData.listeningPort_ = port; - std::map details = DRing::getAccountTemplate("SIP"); + std::map details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::USERNAME] = alias; details[ConfProperties::DISPLAYNAME] = alias; @@ -253,13 +253,13 @@ public: void tearDown() override { - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; std::atomic_bool accountsRemoved {false}; confHandlers.insert( - DRing::exportable_callback([&]() { + libjami::exportable_callback([&]() { auto currAccounts = Manager::instance().getAccountList(); for (auto iter = testAccounts_.begin(); iter != testAccounts_.end();) { auto item = std::find(currAccounts.begin(), currAccounts.end(), *iter); @@ -278,14 +278,14 @@ public: } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().removeAccount(callDataMap_["ALICE"].accountId_, true); Manager::instance().removeAccount(callDataMap_["BOB"].accountId_, true); CPPUNIT_ASSERT( cv.wait_for(lk, std::chrono::seconds(30), [&] { return accountsRemoved.load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } private: @@ -430,13 +430,13 @@ MediaNegotiationTest::validateMediaDirection(std::vector descr void MediaNegotiationTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -454,7 +454,7 @@ MediaNegotiationTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -467,7 +467,7 @@ MediaNegotiationTest::onIncomingCall(const std::string& accountId, CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s]", - DRing::CallSignal::IncomingCall::name, + libjami::CallSignal::IncomingCall::name, callData.alias_.c_str(), callId.c_str()); @@ -484,7 +484,7 @@ MediaNegotiationTest::onIncomingCall(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCall::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCall::name)); callData.cv_.notify_one(); } @@ -492,13 +492,13 @@ MediaNegotiationTest::onIncomingCall(const std::string& accountId, void MediaNegotiationTest::onMediaChangeRequested(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::MediaChangeRequested::name, + libjami::CallSignal::MediaChangeRequested::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -516,7 +516,7 @@ MediaNegotiationTest::onMediaChangeRequested(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::MediaChangeRequested::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::MediaChangeRequested::name)); callData.cv_.notify_one(); } @@ -528,7 +528,7 @@ MediaNegotiationTest::onCallStateChange(const std::string& accountId, CallData& callData) { JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -538,7 +538,7 @@ MediaNegotiationTest::onCallStateChange(const std::string& accountId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } // NOTE. Only states that we are interested in will notify the CV. // If this unit test is modified to process other states, they must @@ -565,7 +565,7 @@ MediaNegotiationTest::onVideoMuted(const std::string& callId, bool muted, CallDa } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::VideoMuted::name, + libjami::CallSignal::VideoMuted::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), muted ? "Mute" : "Un-mute"); @@ -576,7 +576,7 @@ MediaNegotiationTest::onVideoMuted(const std::string& callId, bool muted, CallDa { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::VideoMuted::name, muted ? "muted" : "un-muted")); + CallData::Signal(libjami::CallSignal::VideoMuted::name, muted ? "muted" : "un-muted")); } callData.cv_.notify_one(); @@ -600,7 +600,7 @@ MediaNegotiationTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -611,7 +611,7 @@ MediaNegotiationTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -702,30 +702,30 @@ MediaNegotiationTest::configureScenario() } } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(accountId); if (not user.empty()) onIncomingCallWithMedia(accountId, callId, mediaList, callDataMap_[user]); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(accountId); if (not user.empty()) onMediaChangeRequested(accountId, callId, mediaList, callDataMap_[user]); })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -734,14 +734,14 @@ MediaNegotiationTest::configureScenario() onCallStateChange(accountId, callId, state, callDataMap_[user]); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, bool muted) { auto user = getUserAlias(getAccountId(callId)); if (not user.empty()) onVideoMuted(callId, muted, callDataMap_[user]); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>&) { @@ -750,7 +750,7 @@ MediaNegotiationTest::configureScenario() onMediaNegotiationStatus(callId, event, callDataMap_[user]); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -764,7 +764,7 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, auto mediaCount = scenario.offer_.size(); CPPUNIT_ASSERT_EQUAL(mediaCount, scenario.answer_.size()); - aliceData.callId_ = DRing::placeCallWithMedia(aliceData.accountId_, + aliceData.callId_ = libjami::placeCallWithMedia(aliceData.accountId_, isSipAccount_ ? bobData.toUri_ : callDataMap_["BOB"].userName_, MediaAttribute::mediaAttributesToMediaMaps( @@ -782,24 +782,24 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, bobData.accountId_.c_str()); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. { auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.answer_); - DRing::acceptWithMedia(bobData.accountId_, bobData.callId_, mediaList); + libjami::acceptWithMedia(bobData.accountId_, bobData.callId_, mediaList); } // Wait for media negotiation complete signal. CPPUNIT_ASSERT_EQUAL( true, waitForSignal(bobData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT_EQUAL(true, waitForSignal(bobData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData.callId_.c_str()); @@ -808,8 +808,8 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { @@ -852,7 +852,7 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, JAMI_INFO("=== Request Media Change and validate ==="); { auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.offerUpdate_); - DRing::requestMediaChange(aliceData.accountId_, aliceData.callId_, mediaList); + libjami::requestMediaChange(aliceData.accountId_, aliceData.callId_, mediaList); } // Update and validate media count. @@ -863,11 +863,11 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, if (scenario.expectMediaChangeRequest_) { // Wait for media change request signal. CPPUNIT_ASSERT_EQUAL(true, - waitForSignal(bobData, DRing::CallSignal::MediaChangeRequested::name)); + waitForSignal(bobData, libjami::CallSignal::MediaChangeRequested::name)); // Answer the change request. auto const& mediaList = MediaAttribute::mediaAttributesToMediaMaps(scenario.answerUpdate_); - DRing::answerMediaChangeRequest(bobData.accountId_, bobData.callId_, mediaList); + libjami::answerMediaChangeRequest(bobData.accountId_, bobData.callId_, mediaList); } if (scenario.expectMediaRenegotiation_) { @@ -875,8 +875,8 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, CPPUNIT_ASSERT_EQUAL( true, waitForSignal(aliceData, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media { @@ -919,11 +919,11 @@ MediaNegotiationTest::testWithScenario(CallData& aliceData, // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(bobData.accountId_, bobData.callId_); + libjami::hangUp(bobData.accountId_, bobData.callId_); CPPUNIT_ASSERT_EQUAL(true, waitForSignal(aliceData, - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); @@ -967,7 +967,7 @@ MediaNegotiationTest::audio_and_video_then_caller_mute_video() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1006,7 +1006,7 @@ MediaNegotiationTest::audio_only_then_caller_add_video() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1050,7 +1050,7 @@ MediaNegotiationTest::audio_and_video_then_caller_mute_audio() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1095,7 +1095,7 @@ MediaNegotiationTest::audio_and_video_answer_muted_video_then_mute_video() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1140,7 +1140,7 @@ MediaNegotiationTest::audio_and_video_then_change_video_source() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } @@ -1190,7 +1190,7 @@ MediaNegotiationTest::negotiate_2_videos_1_audio() testWithScenario(callDataMap_["ALICE"], callDataMap_["BOB"], scenario); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); JAMI_INFO("=== End test %s ===", __FUNCTION__); } diff --git a/test/unitTest/plugins/plugins.cpp b/test/unitTest/plugins/plugins.cpp index 72dcf359e..642b2f52a 100644 --- a/test/unitTest/plugins/plugins.cpp +++ b/test/unitTest/plugins/plugins.cpp @@ -37,7 +37,7 @@ #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -83,11 +83,11 @@ public: PluginsTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~PluginsTest() { DRing::fini(); } + ~PluginsTest() { libjami::fini(); } static std::string name() { return "Plugins"; } void setUp(); void tearDown(); @@ -106,7 +106,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); std::string name_{}; @@ -139,13 +139,13 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(PluginsTest, PluginsTest::name()); void PluginsTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -163,7 +163,7 @@ PluginsTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -175,7 +175,7 @@ PluginsTest::onCallStateChange(const std::string& accountId, CallData& callData) { JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -185,7 +185,7 @@ PluginsTest::onCallStateChange(const std::string& accountId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } // NOTE. Only states that we are interested in will notify the CV. // If this unit test is modified to process other states, they must @@ -223,14 +223,14 @@ PluginsTest::setUp() account->enableIceForMedia(true); } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { if (aliceData.accountId_ == accountId) onIncomingCallWithMedia(accountId, callId, mediaList, aliceData); else if (bobData.accountId_ == accountId) @@ -238,7 +238,7 @@ PluginsTest::setUp() })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -248,7 +248,7 @@ PluginsTest::setUp() onCallStateChange(accountId, callId, state, bobData); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); std::ifstream file = jami::fileutils::ifstream("plugins/plugin.yml"); assert(file.is_open()); @@ -266,7 +266,7 @@ PluginsTest::setUp() void PluginsTest::tearDown() { - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); wait_for_removal_of({aliceData.accountId_, bobData.accountId_}); } @@ -529,7 +529,7 @@ PluginsTest::testCall() answer.emplace_back(MediaAttribute(defaultVideo)); JAMI_INFO("Start call between alice and Bob"); - aliceData.callId_ = DRing::placeCallWithMedia(aliceData.accountId_, bobData.userName_, MediaAttribute::mediaAttributesToMediaMaps(request)); + aliceData.callId_ = libjami::placeCallWithMedia(aliceData.accountId_, bobData.userName_, MediaAttribute::mediaAttributesToMediaMaps(request)); CPPUNIT_ASSERT(not aliceData.callId_.empty()); auto aliceCall = std::static_pointer_cast( @@ -543,17 +543,17 @@ PluginsTest::testCall() bobData.accountId_.c_str()); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. { - DRing::acceptWithMedia(bobData.accountId_, bobData.callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); + libjami::acceptWithMedia(bobData.accountId_, bobData.callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); } CPPUNIT_ASSERT_EQUAL(true, waitForSignal(bobData, - DRing::CallSignal::StateChange::name, - DRing::Call::StateEvent::CURRENT)); + libjami::CallSignal::StateChange::name, + libjami::Call::StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData.callId_.c_str()); @@ -581,12 +581,12 @@ PluginsTest::testCall() std::this_thread::sleep_for(std::chrono::seconds(3)); // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(bobData.accountId_, bobData.callId_); + libjami::hangUp(bobData.accountId_, bobData.callId_); CPPUNIT_ASSERT_EQUAL(true, waitForSignal(aliceData, - DRing::CallSignal::StateChange::name, - DRing::Call::StateEvent::HUNGUP)); + libjami::CallSignal::StateChange::name, + libjami::Call::StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); CPPUNIT_ASSERT(!Manager::instance().getJamiPluginManager().uninstallPlugin(installationPath_)); @@ -605,11 +605,11 @@ PluginsTest::testMessage() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -621,28 +621,28 @@ PluginsTest::testMessage() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */) { if (accountId == bobData.accountId_) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - auto convId = DRing::startConversation(aliceData.accountId_); + auto convId = libjami::startConversation(aliceData.accountId_); - DRing::addConversationMember(aliceData.accountId_, convId, bobData.userName_); + libjami::addConversationMember(aliceData.accountId_, convId, bobData.userName_); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobData.accountId_, convId); + libjami::acceptConversationRequest(bobData.accountId_, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Assert that repository exists @@ -666,7 +666,7 @@ PluginsTest::testMessage() auto statusMap = Manager::instance().getJamiPluginManager().getChatServicesManager().getChatHandlerStatus(aliceData.accountId_, convId); CPPUNIT_ASSERT(std::find(statusMap.begin(), statusMap.end(), handler) != statusMap.end()); - DRing::sendMessage(aliceData.accountId_, convId, "hi"s, ""); + libjami::sendMessage(aliceData.accountId_, convId, "hi"s, ""); cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); Manager::instance().getJamiPluginManager().getChatServicesManager().toggleChatHandler(handler, aliceData.accountId_, convId, false); diff --git a/test/unitTest/revoke/revoke.cpp b/test/unitTest/revoke/revoke.cpp index 897de557c..3d8bb4e46 100644 --- a/test/unitTest/revoke/revoke.cpp +++ b/test/unitTest/revoke/revoke.cpp @@ -34,7 +34,7 @@ #include "common.h" using namespace std::string_literals; -using namespace DRing::Account; +using namespace libjami::Account; namespace jami { namespace test { @@ -45,11 +45,11 @@ public: RevokeTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("dring-sample.yml")); + CPPUNIT_ASSERT(libjami::start("dring-sample.yml")); } - ~RevokeTest() { DRing::fini(); } + ~RevokeTest() { libjami::fini(); } static std::string name() { return "Revoke"; } void setUp(); void tearDown(); @@ -90,30 +90,30 @@ RevokeTest::testRevokeDevice() CPPUNIT_ASSERT(aliceAccount->exportArchive("test.gz")); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::ARCHIVE_PATH] = "test.gz"; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto deviceRevoked = false; auto knownChanged = false; std::string alice2Device; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& deviceId, int status) { if (accountId == aliceId && deviceId == alice2Device && status == 0) deviceRevoked = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, auto devices) { if (accountId == aliceId && devices.size() == 2) knownChanged = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); auto alice2Id = jami::Manager::instance().addAccount(details); auto alice2Account = Manager::instance().getAccount(alice2Id); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&] { return knownChanged; })); @@ -133,16 +133,16 @@ RevokeTest::testRevokeInvalidDevice() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto revokeFailed = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& deviceId, int status) { if (accountId == aliceId && deviceId == "foo" && status == 2) revokeFailed = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->revokeDevice("", "foo"); CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&] { return revokeFailed; })); } diff --git a/test/unitTest/sip_account/sip_basic_calls.cpp b/test/unitTest/sip_account/sip_basic_calls.cpp index a469414fc..ebea7bd62 100644 --- a/test/unitTest/sip_account/sip_basic_calls.cpp +++ b/test/unitTest/sip_account/sip_basic_calls.cpp @@ -35,8 +35,8 @@ #include "sip/sipcall.h" #include "sip/sdp.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -84,11 +84,11 @@ public: SipBasicCallTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("dring-sample.yml")); + CPPUNIT_ASSERT(libjami::start("dring-sample.yml")); } - ~SipBasicCallTest() { DRing::fini(); } + ~SipBasicCallTest() { libjami::fini(); } static std::string name() { return "SipBasicCallTest"; } void setUp(); @@ -118,7 +118,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, const std::string& event, @@ -153,7 +153,7 @@ SipBasicCallTest::addTestAccount(const std::string& alias, uint16_t port) callData.alias_ = alias; callData.userName_ = alias; callData.listeningPort_ = port; - std::map details = DRing::getAccountTemplate("SIP"); + std::map details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::USERNAME] = alias; details[ConfProperties::DISPLAYNAME] = alias; @@ -181,13 +181,13 @@ SipBasicCallTest::tearDown() { JAMI_INFO("Remove created accounts..."); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; std::atomic_bool accountsRemoved {false}; confHandlers.insert( - DRing::exportable_callback([&]() { + libjami::exportable_callback([&]() { auto currAccounts = Manager::instance().getAccountList(); for (auto iter = testAccounts_.begin(); iter != testAccounts_.end();) { auto item = std::find(currAccounts.begin(), currAccounts.end(), *iter); @@ -206,7 +206,7 @@ SipBasicCallTest::tearDown() } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().removeAccount(callDataMap_["ALICE"].accountId_, true); Manager::instance().removeAccount(callDataMap_["BOB"].accountId_, true); @@ -215,7 +215,7 @@ SipBasicCallTest::tearDown() CPPUNIT_ASSERT( cv.wait_for(lk, std::chrono::seconds(30), [&] { return accountsRemoved.load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } std::string @@ -260,13 +260,13 @@ SipBasicCallTest::getUserAlias(const std::string& accountId) void SipBasicCallTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -279,7 +279,7 @@ SipBasicCallTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -291,7 +291,7 @@ SipBasicCallTest::onCallStateChange(const std::string& accountId, CallData& callData) { JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -301,7 +301,7 @@ SipBasicCallTest::onCallStateChange(const std::string& accountId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } // NOTE. Only states that we are interested on will notify the CV. If this // unit test is modified to process other states, they must be added here. @@ -328,7 +328,7 @@ SipBasicCallTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -339,7 +339,7 @@ SipBasicCallTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -419,14 +419,14 @@ SipBasicCallTest::configureTest() account->setLocalPort(callDataMap_["CARLA"].listeningPort_); } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto alias = getUserAlias(accountId); if (not alias.empty()) { onIncomingCallWithMedia(accountId, callId, mediaList, callDataMap_[alias]); @@ -434,7 +434,7 @@ SipBasicCallTest::configureTest() })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -443,7 +443,7 @@ SipBasicCallTest::configureTest() onCallStateChange(accountId, callId, state, callDataMap_[alias]); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>& /* mediaList */) { @@ -452,7 +452,7 @@ SipBasicCallTest::configureTest() onMediaNegotiationStatus(callId, event, callDataMap_[alias]); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -469,7 +469,7 @@ SipBasicCallTest::audio_video_call(std::vector offer, + "@127.0.0.1:" + std::to_string(callDataMap_["BOB"].listeningPort_); callDataMap_["ALICE"].callId_ - = DRing::placeCallWithMedia(callDataMap_["ALICE"].accountId_, + = libjami::placeCallWithMedia(callDataMap_["ALICE"].accountId_, bobUri, MediaAttribute::mediaAttributesToMediaMaps(offer)); @@ -484,15 +484,15 @@ SipBasicCallTest::audio_video_call(std::vector offer, // Wait for call to be processed. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. CPPUNIT_ASSERT( - waitForSignal(callDataMap_["BOB"], DRing::CallSignal::IncomingCallWithMedia::name)); + waitForSignal(callDataMap_["BOB"], libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(callDataMap_["BOB"].accountId_, + libjami::acceptWithMedia(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); @@ -500,12 +500,12 @@ SipBasicCallTest::audio_video_call(std::vector offer, // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", callDataMap_["BOB"].callId_.c_str()); @@ -513,8 +513,8 @@ SipBasicCallTest::audio_video_call(std::vector offer, // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media if (validateMedia) { auto call = Manager::instance().getCallFromCallID(callDataMap_["ALICE"].callId_); @@ -552,12 +552,12 @@ SipBasicCallTest::audio_video_call(std::vector offer, // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_); + libjami::hangUp(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_); } else { // The media negotiation for the call is expected to fail, so we // should receive the signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::FAILURE)); } @@ -565,7 +565,7 @@ SipBasicCallTest::audio_video_call(std::vector offer, // success failure scenarios. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); @@ -718,7 +718,7 @@ SipBasicCallTest::hold_resume_test() + "@127.0.0.1:" + std::to_string(callDataMap_["BOB"].listeningPort_); callDataMap_["ALICE"].callId_ - = DRing::placeCallWithMedia(callDataMap_["ALICE"].accountId_, + = libjami::placeCallWithMedia(callDataMap_["ALICE"].accountId_, bobUri, MediaAttribute::mediaAttributesToMediaMaps(offer)); @@ -733,27 +733,27 @@ SipBasicCallTest::hold_resume_test() // Wait for call to be processed. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. CPPUNIT_ASSERT( - waitForSignal(callDataMap_["BOB"], DRing::CallSignal::IncomingCallWithMedia::name)); + waitForSignal(callDataMap_["BOB"], libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(callDataMap_["BOB"].accountId_, + libjami::acceptWithMedia(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", callDataMap_["BOB"].callId_.c_str()); @@ -761,8 +761,8 @@ SipBasicCallTest::hold_resume_test() // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's side of media direction { @@ -793,17 +793,17 @@ SipBasicCallTest::hold_resume_test() // Hold/Resume the call JAMI_INFO("Hold Alice's call"); - DRing::hold(callDataMap_["ALICE"].accountId_, callDataMap_["ALICE"].callId_); + libjami::hold(callDataMap_["ALICE"].accountId_, callDataMap_["ALICE"].callId_); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HOLD)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); { // Validate hold state. auto call = Manager::instance().getCallFromCallID(callDataMap_["ALICE"].callId_); @@ -850,18 +850,18 @@ SipBasicCallTest::hold_resume_test() std::this_thread::sleep_for(std::chrono::seconds(2)); JAMI_INFO("Resume Alice's call"); - DRing::unhold(callDataMap_["ALICE"].accountId_, callDataMap_["ALICE"].callId_); + libjami::unhold(callDataMap_["ALICE"].accountId_, callDataMap_["ALICE"].callId_); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT( waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); std::this_thread::sleep_for(std::chrono::seconds(2)); { @@ -875,13 +875,13 @@ SipBasicCallTest::hold_resume_test() // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_); + libjami::hangUp(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_); // The hang-up signal will be emitted on caller's side (Alice) in both // success and failure scenarios. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); @@ -958,7 +958,7 @@ SipBasicCallTest::blind_transfer_test() + "@127.0.0.1:" + std::to_string(callDataMap_["BOB"].listeningPort_); callDataMap_["ALICE"].callId_ - = DRing::placeCallWithMedia(callDataMap_["ALICE"].accountId_, + = libjami::placeCallWithMedia(callDataMap_["ALICE"].accountId_, bobUri, MediaAttribute::mediaAttributesToMediaMaps(offer)); @@ -973,34 +973,34 @@ SipBasicCallTest::blind_transfer_test() // Wait for call to be processed. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. CPPUNIT_ASSERT( - waitForSignal(callDataMap_["BOB"], DRing::CallSignal::IncomingCallWithMedia::name)); + waitForSignal(callDataMap_["BOB"], libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(callDataMap_["BOB"].accountId_, + libjami::acceptWithMedia(callDataMap_["BOB"].accountId_, callDataMap_["BOB"].callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", callDataMap_["BOB"].callId_.c_str()); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Give some time to media to start and flow std::this_thread::sleep_for(std::chrono::seconds(2)); @@ -1009,51 +1009,51 @@ SipBasicCallTest::blind_transfer_test() std::string carlaUri = carlaAcc->getUsername() + "@127.0.0.1:" + std::to_string(callDataMap_["CARLA"].listeningPort_); - DRing::transfer(callDataMap_["ALICE"].accountId_, + libjami::transfer(callDataMap_["ALICE"].accountId_, callDataMap_["ALICE"].callId_, carlaUri); // TODO. Check trim // Expect Alice's call to end. CPPUNIT_ASSERT(waitForSignal(callDataMap_["ALICE"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); // Wait for the new call to be processed. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. CPPUNIT_ASSERT( - waitForSignal(callDataMap_["CARLA"], DRing::CallSignal::IncomingCallWithMedia::name)); + waitForSignal(callDataMap_["CARLA"], libjami::CallSignal::IncomingCallWithMedia::name)); // Let it ring std::this_thread::sleep_for(std::chrono::seconds(2)); // Carla answers the call. - DRing::acceptWithMedia(callDataMap_["CARLA"].accountId_, + libjami::acceptWithMedia(callDataMap_["CARLA"].accountId_, callDataMap_["CARLA"].callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["CARLA"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["CARLA"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("CARLA answered the call [%s]", callDataMap_["BOB"].callId_.c_str()); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT(waitForSignal(callDataMap_["BOB"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); // Validate Carla's side of media direction @@ -1080,11 +1080,11 @@ SipBasicCallTest::blind_transfer_test() // Bob hang-up. JAMI_INFO("Hang up CARLA's call and wait for CARLA to hang up"); - DRing::hangUp(callDataMap_["CARLA"].accountId_, callDataMap_["CARLA"].callId_); + libjami::hangUp(callDataMap_["CARLA"].accountId_, callDataMap_["CARLA"].callId_); // Expect end call on Carla's side. CPPUNIT_ASSERT(waitForSignal(callDataMap_["CARLA"], - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Calls normally ended on both sides"); diff --git a/test/unitTest/sip_account/sip_srtp.cpp b/test/unitTest/sip_account/sip_srtp.cpp index bb6eb8a6c..fbe1d8173 100644 --- a/test/unitTest/sip_account/sip_srtp.cpp +++ b/test/unitTest/sip_account/sip_srtp.cpp @@ -34,8 +34,8 @@ #include "account_const.h" #include "sip/sipcall.h" #include "sip/sdp.h" -using namespace DRing::Account; -using namespace DRing::Call; +using namespace libjami::Account; +using namespace libjami::Call; namespace jami { namespace test { @@ -71,11 +71,11 @@ public: SipSrtpTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("dring-sample.yml")); + CPPUNIT_ASSERT(libjami::start("dring-sample.yml")); } - ~SipSrtpTest() { DRing::fini(); } + ~SipSrtpTest() { libjami::fini(); } static std::string name() { return "SipSrtpTest"; } void setUp(); @@ -97,7 +97,7 @@ private: CallData& callData); static void onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData); static void onMediaNegotiationStatus(const std::string& callId, const std::string& event, @@ -126,7 +126,7 @@ void SipSrtpTest::setUp() { aliceData_.listeningPort_ = 5080; - std::map details = DRing::getAccountTemplate("SIP"); + std::map details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "ALICE"; details[ConfProperties::ALIAS] = "ALICE"; @@ -136,7 +136,7 @@ SipSrtpTest::setUp() aliceData_.accountId_ = Manager::instance().addAccount(details); bobData_.listeningPort_ = 5082; - details = DRing::getAccountTemplate("SIP"); + details = libjami::getAccountTemplate("SIP"); details[ConfProperties::TYPE] = "SIP"; details[ConfProperties::DISPLAYNAME] = "BOB"; details[ConfProperties::ALIAS] = "BOB"; @@ -155,20 +155,20 @@ SipSrtpTest::tearDown() { JAMI_INFO("Remove created accounts..."); - std::map> confHandlers; + std::map> confHandlers; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; auto currentAccSize = Manager::instance().getAccountList().size(); std::atomic_bool accountsRemoved {false}; confHandlers.insert( - DRing::exportable_callback([&]() { + libjami::exportable_callback([&]() { if (Manager::instance().getAccountList().size() <= currentAccSize - 2) { accountsRemoved = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); Manager::instance().removeAccount(aliceData_.accountId_, true); Manager::instance().removeAccount(bobData_.accountId_, true); @@ -176,7 +176,7 @@ SipSrtpTest::tearDown() CPPUNIT_ASSERT( cv.wait_for(lk, std::chrono::seconds(30), [&] { return accountsRemoved.load(); })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } std::string @@ -200,13 +200,13 @@ SipSrtpTest::getUserAlias(const std::string& callId) void SipSrtpTest::onIncomingCallWithMedia(const std::string& accountId, const std::string& callId, - const std::vector mediaList, + const std::vector mediaList, CallData& callData) { CPPUNIT_ASSERT_EQUAL(callData.accountId_, accountId); JAMI_INFO("Signal [%s] - user [%s] - call [%s] - media count [%lu]", - DRing::CallSignal::IncomingCallWithMedia::name, + libjami::CallSignal::IncomingCallWithMedia::name, callData.alias_.c_str(), callId.c_str(), mediaList.size()); @@ -224,7 +224,7 @@ SipSrtpTest::onIncomingCallWithMedia(const std::string& accountId, std::unique_lock lock {callData.mtx_}; callData.callId_ = callId; - callData.signals_.emplace_back(CallData::Signal(DRing::CallSignal::IncomingCallWithMedia::name)); + callData.signals_.emplace_back(CallData::Signal(libjami::CallSignal::IncomingCallWithMedia::name)); callData.cv_.notify_one(); } @@ -248,7 +248,7 @@ SipSrtpTest::onCallStateChange(const std::string&, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::StateChange::name, + libjami::CallSignal::StateChange::name, callData.alias_.c_str(), callId.c_str(), state.c_str()); @@ -259,7 +259,7 @@ SipSrtpTest::onCallStateChange(const std::string&, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::StateChange::name, state)); + CallData::Signal(libjami::CallSignal::StateChange::name, state)); } // NOTE. Only states that we are interested on will notify the CV. If this // unit test is modified to process other states, they must be added here. @@ -286,7 +286,7 @@ SipSrtpTest::onMediaNegotiationStatus(const std::string& callId, } JAMI_INFO("Signal [%s] - user [%s] - call [%s] - state [%s]", - DRing::CallSignal::MediaNegotiationStatus::name, + libjami::CallSignal::MediaNegotiationStatus::name, account->getAccountDetails()[ConfProperties::ALIAS].c_str(), call->getCallId().c_str(), event.c_str()); @@ -297,7 +297,7 @@ SipSrtpTest::onMediaNegotiationStatus(const std::string& callId, { std::unique_lock lock {callData.mtx_}; callData.signals_.emplace_back( - CallData::Signal(DRing::CallSignal::MediaNegotiationStatus::name, event)); + CallData::Signal(libjami::CallSignal::MediaNegotiationStatus::name, event)); } callData.cv_.notify_one(); @@ -372,14 +372,14 @@ SipSrtpTest::configureTest(CallData& aliceData, CallData& bobData) account->setLocalPort(bobData.listeningPort_); } - std::map> signalHandlers; + std::map> signalHandlers; // Insert needed signal handlers. - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& callId, const std::string&, - const std::vector mediaList) { + const std::vector mediaList) { auto user = getUserAlias(callId); if (not user.empty()) onIncomingCallWithMedia(accountId, @@ -389,7 +389,7 @@ SipSrtpTest::configureTest(CallData& aliceData, CallData& bobData) })); signalHandlers.insert( - DRing::exportable_callback([&](const std::string& accountId, + libjami::exportable_callback([&](const std::string& accountId, const std::string& callId, const std::string& state, signed) { @@ -401,7 +401,7 @@ SipSrtpTest::configureTest(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - signalHandlers.insert(DRing::exportable_callback( + signalHandlers.insert(libjami::exportable_callback( [&](const std::string& callId, const std::string& event, const std::vector>& /* mediaList */) { @@ -412,7 +412,7 @@ SipSrtpTest::configureTest(CallData& aliceData, CallData& bobData) user == aliceData.alias_ ? aliceData : bobData); })); - DRing::registerSignalHandlers(signalHandlers); + libjami::registerSignalHandlers(signalHandlers); } void @@ -428,7 +428,7 @@ SipSrtpTest::audio_video_call(std::vector offer, std::string bobUri = "127.0.0.1:" + std::to_string(bobData_.listeningPort_); - aliceData_.callId_ = DRing::placeCallWithMedia(aliceData_.accountId_, + aliceData_.callId_ = libjami::placeCallWithMedia(aliceData_.accountId_, bobUri, MediaAttribute::mediaAttributesToMediaMaps( offer)); @@ -444,31 +444,31 @@ SipSrtpTest::audio_video_call(std::vector offer, // Wait for call to be processed. CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::RINGING)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::RINGING)); // Wait for incoming call signal. - CPPUNIT_ASSERT(waitForSignal(bobData_, DRing::CallSignal::IncomingCallWithMedia::name)); + CPPUNIT_ASSERT(waitForSignal(bobData_, libjami::CallSignal::IncomingCallWithMedia::name)); // Answer the call. - DRing::acceptWithMedia(bobData_.accountId_, + libjami::acceptWithMedia(bobData_.accountId_, bobData_.callId_, MediaAttribute::mediaAttributesToMediaMaps(answer)); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(bobData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Wait for the StateChange signal. CPPUNIT_ASSERT( - waitForSignal(bobData_, DRing::CallSignal::StateChange::name, StateEvent::CURRENT)); + waitForSignal(bobData_, libjami::CallSignal::StateChange::name, StateEvent::CURRENT)); JAMI_INFO("BOB answered the call [%s]", bobData_.callId_.c_str()); // Wait for media negotiation complete signal. CPPUNIT_ASSERT(waitForSignal(aliceData_, - DRing::CallSignal::MediaNegotiationStatus::name, - DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); + libjami::CallSignal::MediaNegotiationStatus::name, + libjami::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS)); // Validate Alice's media if (validateMedia) { @@ -507,10 +507,10 @@ SipSrtpTest::audio_video_call(std::vector offer, // Bob hang-up. JAMI_INFO("Hang up BOB's call and wait for ALICE to hang up"); - DRing::hangUp(bobData_.accountId_, bobData_.callId_); + libjami::hangUp(bobData_.accountId_, bobData_.callId_); CPPUNIT_ASSERT( - waitForSignal(aliceData_, DRing::CallSignal::StateChange::name, StateEvent::HUNGUP)); + waitForSignal(aliceData_, libjami::CallSignal::StateChange::name, StateEvent::HUNGUP)); JAMI_INFO("Call terminated on both sides"); } diff --git a/test/unitTest/syncHistory/syncHistory.cpp b/test/unitTest/syncHistory/syncHistory.cpp index 5c9393dc8..01feade71 100644 --- a/test/unitTest/syncHistory/syncHistory.cpp +++ b/test/unitTest/syncHistory/syncHistory.cpp @@ -34,7 +34,7 @@ #include "account_const.h" #include "common.h" -using namespace DRing::Account; +using namespace libjami::Account; using namespace std::literals::chrono_literals; namespace jami { @@ -46,11 +46,11 @@ public: SyncHistoryTest() { // Init daemon - DRing::init(DRing::InitFlag(DRing::DRING_FLAG_DEBUG | DRing::DRING_FLAG_CONSOLE_LOG)); + libjami::init(libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); if (not Manager::instance().initialized) - CPPUNIT_ASSERT(DRing::start("jami-sample.yml")); + CPPUNIT_ASSERT(libjami::start("jami-sample.yml")); } - ~SyncHistoryTest() { DRing::fini(); } + ~SyncHistoryTest() { libjami::fini(); } static std::string name() { return "SyncHistory"; } void setUp(); void tearDown(); @@ -121,12 +121,12 @@ SyncHistoryTest::testCreateConversationThenSync() { auto aliceAccount = Manager::instance().getAccount(aliceId); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -138,9 +138,9 @@ SyncHistoryTest::testCreateConversationThenSync() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto conversationReady = false, alice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == alice2Id && conversationId == convId) { conversationReady = true; @@ -148,19 +148,19 @@ SyncHistoryTest::testCreateConversationThenSync() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready && conversationReady; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -171,7 +171,7 @@ SyncHistoryTest::testCreateConversationWithOnlineDevice() // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -183,12 +183,12 @@ SyncHistoryTest::testCreateConversationWithOnlineDevice() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; // Start conversation now - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); auto conversationReady = false, alice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == alice2Id && conversationId == convId) { conversationReady = true; @@ -196,65 +196,65 @@ SyncHistoryTest::testCreateConversationWithOnlineDevice() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return alice2Ready && conversationReady; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void SyncHistoryTest::testCreateConversationWithMessagesThenAddDevice() { auto aliceAccount = Manager::instance().getAccount(aliceId); - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto conversationReady = false; auto messageReceived = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, std::map /*message*/) { messageReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == alice2Id && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); confHandlers.clear(); // Start conversation messageReceived = false; - DRing::sendMessage(aliceId, convId, std::string("Message 1"), ""); + libjami::sendMessage(aliceId, convId, std::string("Message 1"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(aliceId, convId, std::string("Message 2"), ""); + libjami::sendMessage(aliceId, convId, std::string("Message 2"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(aliceId, convId, std::string("Message 3"), ""); + libjami::sendMessage(aliceId, convId, std::string("Message 3"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -267,7 +267,7 @@ SyncHistoryTest::testCreateConversationWithMessagesThenAddDevice() // Check if conversation is ready CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady; })); std::vector> messages; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](uint32_t, const std::string& accountId, const std::string& conversationId, @@ -277,10 +277,10 @@ SyncHistoryTest::testCreateConversationWithMessagesThenAddDevice() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); - DRing::loadConversationMessages(alice2Id, convId, "", 0); + libjami::registerSignalHandlers(confHandlers); + libjami::loadConversationMessages(alice2Id, convId, "", 0); cv.wait_for(lk, 30s); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); confHandlers.clear(); // Check messages @@ -295,30 +295,30 @@ SyncHistoryTest::testCreateMultipleConversationThenAddDevice() { auto aliceAccount = Manager::instance().getAccount(aliceId); // Start conversation - auto convId = DRing::startConversation(aliceId); - DRing::sendMessage(aliceId, convId, std::string("Message 1"), ""); - DRing::sendMessage(aliceId, convId, std::string("Message 2"), ""); - DRing::sendMessage(aliceId, convId, std::string("Message 3"), ""); + auto convId = libjami::startConversation(aliceId); + libjami::sendMessage(aliceId, convId, std::string("Message 1"), ""); + libjami::sendMessage(aliceId, convId, std::string("Message 2"), ""); + libjami::sendMessage(aliceId, convId, std::string("Message 3"), ""); std::this_thread::sleep_for(1s); - auto convId2 = DRing::startConversation(aliceId); - DRing::sendMessage(aliceId, convId2, std::string("Message 1"), ""); - DRing::sendMessage(aliceId, convId2, std::string("Message 2"), ""); - DRing::sendMessage(aliceId, convId2, std::string("Message 3"), ""); + auto convId2 = libjami::startConversation(aliceId); + libjami::sendMessage(aliceId, convId2, std::string("Message 1"), ""); + libjami::sendMessage(aliceId, convId2, std::string("Message 2"), ""); + libjami::sendMessage(aliceId, convId2, std::string("Message 3"), ""); std::this_thread::sleep_for(1s); - auto convId3 = DRing::startConversation(aliceId); - DRing::sendMessage(aliceId, convId3, std::string("Message 1"), ""); - DRing::sendMessage(aliceId, convId3, std::string("Message 2"), ""); - DRing::sendMessage(aliceId, convId3, std::string("Message 3"), ""); + auto convId3 = libjami::startConversation(aliceId); + libjami::sendMessage(aliceId, convId3, std::string("Message 1"), ""); + libjami::sendMessage(aliceId, convId3, std::string("Message 2"), ""); + libjami::sendMessage(aliceId, convId3, std::string("Message 3"), ""); std::this_thread::sleep_for(1s); - auto convId4 = DRing::startConversation(aliceId); - DRing::sendMessage(aliceId, convId4, std::string("Message 1"), ""); - DRing::sendMessage(aliceId, convId4, std::string("Message 2"), ""); - DRing::sendMessage(aliceId, convId4, std::string("Message 3"), ""); + auto convId4 = libjami::startConversation(aliceId); + libjami::sendMessage(aliceId, convId4, std::string("Message 1"), ""); + libjami::sendMessage(aliceId, convId4, std::string("Message 2"), ""); + libjami::sendMessage(aliceId, convId4, std::string("Message 3"), ""); // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -331,21 +331,21 @@ SyncHistoryTest::testCreateMultipleConversationThenAddDevice() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; std::atomic_int conversationReady = 0; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string&) { if (accountId == alice2Id) { conversationReady += 1; cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); confHandlers.clear(); // Check if conversation is ready CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady == 4; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -361,16 +361,16 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() auto uri = aliceAccount->getUsername(); // Start conversation for Alice - auto convId = DRing::startConversation(bobId); + auto convId = libjami::startConversation(bobId); // Check that alice receives the request std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false, memberEvent = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -380,7 +380,7 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /*conversationId*/, const std::string& /*memberUri*/, @@ -388,16 +388,16 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() memberEvent = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); memberEvent = false; - DRing::addConversationMember(bobId, convId, uri); + libjami::addConversationMember(bobId, convId, uri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return memberEvent && requestReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); confHandlers.clear(); // Now create alice2 - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -409,7 +409,7 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -418,10 +418,10 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -432,7 +432,7 @@ SyncHistoryTest::testRemoveConversationOnAllDevices() // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -444,20 +444,20 @@ SyncHistoryTest::testRemoveConversationOnAllDevices() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; // Start conversation now - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); bool alice2Ready = false; auto conversationReady = false, conversationRemoved = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == alice2Id && conversationId == convId) { conversationReady = true; cv.notify_one(); } })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == alice2Id && conversationId == convId) { conversationRemoved = true; @@ -465,23 +465,23 @@ SyncHistoryTest::testRemoveConversationOnAllDevices() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return alice2Ready && conversationReady; })); - DRing::removeConversation(aliceId, convId); + libjami::removeConversation(aliceId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return conversationRemoved; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -496,17 +496,17 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() aliceAccount->exportArchive(aliceArchive); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool alice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -518,14 +518,14 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId) { conversationReady = true; @@ -538,21 +538,21 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // Wait that alice sees Bob @@ -562,7 +562,7 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() Manager::instance().sendRegister(aliceId, false); std::this_thread::sleep_for(5s); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -576,16 +576,16 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready; })); // This will trigger a conversation request. Cause alice2 can't know first conversation - DRing::sendMessage(bobId, convId, std::string("hi"), ""); + libjami::sendMessage(bobId, convId, std::string("hi"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); - DRing::acceptConversationRequest(alice2Id, convId); + libjami::acceptConversationRequest(alice2Id, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return conversationReady; })); messageBobReceived = 0; - DRing::sendMessage(alice2Id, convId, std::string("hi"), ""); + libjami::sendMessage(alice2Id, convId, std::string("hi"), ""); cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -597,18 +597,18 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() auto bobUri = bobAccount->getUsername(); // Start conversation - auto convId = DRing::startConversation(aliceId); + auto convId = libjami::startConversation(aliceId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0; bool requestReceived = false; bool conversationReady = false; bool alice2Ready = false; bool memberAddGenerated = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -618,7 +618,7 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, const std::string& uri, @@ -630,14 +630,14 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (conversationId != convId) return; @@ -646,21 +646,21 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(aliceId, convId, bobUri); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - DRing::acceptConversationRequest(bobId, convId); + libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); // We need to track presence to know when to sync @@ -677,7 +677,7 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() Manager::instance().sendRegister(aliceId, false); std::this_thread::sleep_for(5s); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -693,9 +693,9 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return conversationReady; })); messageBobReceived = 0; - DRing::sendMessage(alice2Id, convId, std::string("hi"), ""); + libjami::sendMessage(alice2Id, convId, std::string("hi"), ""); cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -707,17 +707,17 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() auto aliceUri = aliceAccount->getUsername(); // Start conversation - auto convId = DRing::startConversation(bobId); + auto convId = libjami::startConversation(bobId); std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageBobReceived = 0, messageAliceReceived = 0; bool requestReceived = false; bool conversationReady = false; bool alice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, std::map /*message*/) { @@ -729,14 +729,14 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/) { requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId) { conversationReady = true; @@ -749,18 +749,18 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(bobId, convId, aliceUri); + libjami::addConversationMember(bobId, convId, aliceUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); // Backup alice after startConversation with member @@ -771,7 +771,7 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() Manager::instance().sendRegister(aliceId, false); std::this_thread::sleep_for(5s); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -784,10 +784,10 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready; })); // Should get the same request as before. - DRing::acceptConversationRequest(alice2Id, convId); + libjami::acceptConversationRequest(alice2Id, convId); CPPUNIT_ASSERT( cv.wait_for(lk, 30s, [&]() { return conversationReady && messageBobReceived == 1; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -801,9 +801,9 @@ SyncHistoryTest::testSyncOneToOne() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto conversationReady = false, alice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) convId = conversationId; @@ -812,16 +812,16 @@ SyncHistoryTest::testSyncOneToOne() cv.notify_one(); })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::map& details) { if (alice2Id != accountId) { return; } - alice2Ready = details.at(DRing::Account::VolatileProperties::DEVICE_ANNOUNCED) + alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) == "true"; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobAccount->getUsername()); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !convId.empty(); })); @@ -829,7 +829,7 @@ SyncHistoryTest::testSyncOneToOne() // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -840,7 +840,7 @@ SyncHistoryTest::testSyncOneToOne() alice2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready && conversationReady; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -856,16 +856,16 @@ SyncHistoryTest::testConversationRequestRemoved() auto uri = aliceAccount->getUsername(); // Start conversation for Alice - auto convId = DRing::startConversation(bobId); + auto convId = libjami::startConversation(bobId); // Check that alice receives the request std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -874,15 +874,15 @@ SyncHistoryTest::testConversationRequestRemoved() cv.notify_one(); } })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); - DRing::addConversationMember(bobId, convId, uri); + libjami::addConversationMember(bobId, convId, uri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); confHandlers.clear(); // Now create alice2 - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -895,7 +895,7 @@ SyncHistoryTest::testConversationRequestRemoved() requestReceived = false; bool requestDeclined = false, requestDeclined2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, std::map /*metadatas*/) { @@ -905,7 +905,7 @@ SyncHistoryTest::testConversationRequestRemoved() } })); confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (conversationId != convId) return; @@ -915,15 +915,15 @@ SyncHistoryTest::testConversationRequestRemoved() requestDeclined2 = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); // Now decline trust request, this should trigger ConversationRequestDeclined both sides for Alice - DRing::declineConversationRequest(aliceId, convId); + libjami::declineConversationRequest(aliceId, convId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestDeclined && requestDeclined2; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -967,12 +967,12 @@ END:VCARD"; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; bool conversationReady = false, requestReceived = false, bobProfileReceived = false, aliceProfileReceived = false; std::string convId = ""; std::string bobDest = aliceAccount->dataTransfer()->profilePath(bobUri); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& account_id, const std::string& /*from*/, const std::string& /*conversationId*/, @@ -982,7 +982,7 @@ END:VCARD"; requestReceived = true; cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == aliceId) { convId = conversationId; @@ -991,7 +991,7 @@ END:VCARD"; } cv.notify_one(); })); - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& peerId, const std::string& path) { if (accountId == aliceId && peerId == bobUri) { bobProfileReceived = true; @@ -1007,7 +1007,7 @@ END:VCARD"; } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); @@ -1019,7 +1019,7 @@ END:VCARD"; CPPUNIT_ASSERT(fileutils::isFile(bobDest)); // Now create alice2 - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -1031,7 +1031,7 @@ END:VCARD"; alice2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return aliceProfileReceived && bobProfileReceived; })); - DRing::unregisterSignalHandlers(); + libjami::unregisterSignalHandlers(); } void @@ -1046,10 +1046,10 @@ SyncHistoryTest::testLastInteractionAfterClone() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageReceived = false; std::string msgId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, std::map message) { @@ -1058,7 +1058,7 @@ SyncHistoryTest::testLastInteractionAfterClone() cv.notify_one(); })); auto conversationReady = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId || accountId == alice2Id) { convId = conversationId; @@ -1068,7 +1068,7 @@ SyncHistoryTest::testLastInteractionAfterClone() })); auto requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& /*conversationId*/, std::map /*metadatas*/) { @@ -1078,7 +1078,7 @@ SyncHistoryTest::testLastInteractionAfterClone() })); auto messageDisplayed = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, const std::string& /* username */, @@ -1088,7 +1088,7 @@ SyncHistoryTest::testLastInteractionAfterClone() messageDisplayed = true; cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); confHandlers.clear(); aliceAccount->addContact(bobUri); @@ -1100,24 +1100,24 @@ SyncHistoryTest::testLastInteractionAfterClone() // Start conversation messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 1"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 1"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 2"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 2"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 3"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 3"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageDisplayed = false; - DRing::setMessageDisplayed(aliceId, "swarm:" + convId, msgId, 3); + libjami::setMessageDisplayed(aliceId, "swarm:" + convId, msgId, 3); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageDisplayed; })); // Now create alice2 conversationReady = false; auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -1130,7 +1130,7 @@ SyncHistoryTest::testLastInteractionAfterClone() // Check if conversation is ready CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady; })); // Check that last displayed is synched - auto membersInfos = DRing::getConversationMembers(alice2Id, convId); + auto membersInfos = libjami::getConversationMembers(alice2Id, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1152,10 +1152,10 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; - std::map> confHandlers; + std::map> confHandlers; auto messageReceived = false; std::string msgId = ""; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& /* accountId */, const std::string& /* conversationId */, std::map message) { @@ -1164,7 +1164,7 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() cv.notify_one(); })); auto conversationReady = false, conversationAlice2Ready = false; - confHandlers.insert(DRing::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId) { if (accountId == bobId) { convId = conversationId; @@ -1176,7 +1176,7 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() })); auto requestReceived = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& /*conversationId*/, std::map /*metadatas*/) { @@ -1186,7 +1186,7 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() })); auto messageDisplayed = false, messageDisplayedAlice2 = false; confHandlers.insert( - DRing::exportable_callback( + libjami::exportable_callback( [&](const std::string& accountId, const std::string& /* conversationId */, const std::string& /* username */, @@ -1200,13 +1200,13 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() } cv.notify_one(); })); - DRing::registerSignalHandlers(confHandlers); + libjami::registerSignalHandlers(confHandlers); confHandlers.clear(); // Creates alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - std::map details = DRing::getAccountTemplate("RING"); + std::map details = libjami::getAccountTemplate("RING"); details[ConfProperties::TYPE] = "RING"; details[ConfProperties::DISPLAYNAME] = "ALICE2"; details[ConfProperties::ALIAS] = "ALICE2"; @@ -1226,22 +1226,22 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() // Start conversation messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 1"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 1"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 2"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 2"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageReceived = false; - DRing::sendMessage(bobId, convId, std::string("Message 3"), ""); + libjami::sendMessage(bobId, convId, std::string("Message 3"), ""); CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); messageDisplayed = false; messageDisplayedAlice2 = false; auto displayedId = msgId; - DRing::setMessageDisplayed(aliceId, "swarm:" + convId, displayedId, 3); + libjami::setMessageDisplayed(aliceId, "swarm:" + convId, displayedId, 3); CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return messageDisplayed && messageDisplayedAlice2; })); - auto membersInfos = DRing::getConversationMembers(alice2Id, convId); + auto membersInfos = libjami::getConversationMembers(alice2Id, convId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { diff --git a/tools/jamictrl/controller.py b/tools/jamictrl/controller.py index beb61bba7..665d657dd 100644 --- a/tools/jamictrl/controller.py +++ b/tools/jamictrl/controller.py @@ -19,7 +19,7 @@ # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # -"""DRing controlling class through DBUS""" +"""libjami controlling class through DBUS""" import sys import os @@ -29,24 +29,24 @@ import hashlib from threading import Thread from functools import partial -from errorsDring import DRingCtrlAccountError, DRingCtrlError, DRingCtrlDBusError, DRingCtrlDeamonError +from errorsDring import libjamiCtrlAccountError, libjamiCtrlError, libjamiCtrlDBusError, libjamiCtrlDeamonError from gi.repository import GLib try: import dbus from dbus.mainloop.glib import DBusGMainLoop except ImportError as e: - raise DRingCtrlError(str(e)) + raise libjamiCtrlError(str(e)) DBUS_DEAMON_OBJECT = 'cx.ring.Ring' DBUS_DEAMON_PATH = '/cx/ring/Ring' -class DRingCtrl(Thread): +class libjamiCtrl(Thread): def __init__(self, name, autoAnswer): if sys.version_info[0] < 3: - super(DRingCtrl, self).__init__() + super(libjamiCtrl, self).__init__() else: super().__init__() @@ -85,10 +85,10 @@ class DRingCtrl(Thread): bus = dbus.SessionBus() except dbus.DBusException as e: - raise DRingCtrlDBusError(str(e)) + raise libjamiCtrlDBusError(str(e)) if not bus.name_has_owner(DBUS_DEAMON_OBJECT) : - raise DRingCtrlDBusError(("Unable to find %s in DBUS." % DBUS_DEAMON_OBJECT) + raise libjamiCtrlDBusError(("Unable to find %s in DBUS." % DBUS_DEAMON_OBJECT) + " Check if jami is running") try: @@ -112,14 +112,14 @@ class DRingCtrl(Thread): DBUS_DEAMON_OBJECT+'.VideoManager') except dbus.DBusException as e: - raise DRingCtrlDBusError("Unable to bind to jami DBus API") + raise libjamiCtrlDBusError("Unable to bind to jami DBus API") try: self.instance.Register(os.getpid(), self.name) self.registered = True except dbus.DBusException as e: - raise DRingCtrlDeamonError("Client registration failed") + raise libjamiCtrlDeamonError("Client registration failed") try: proxy_callmgr.connect_to_signal('incomingCall', self.onIncomingCall) @@ -133,7 +133,7 @@ class DRingCtrl(Thread): proxy_confmgr.connect_to_signal('messageReceived', self.onMessageReceived) except dbus.DBusException as e: - raise DRingCtrlDBusError("Unable to connect to jami DBus signals") + raise libjamiCtrlDBusError("Unable to connect to jami DBus signals") def unregister(self): @@ -145,7 +145,7 @@ class DRingCtrl(Thread): self.registered = False except: - raise DRingCtrlDeamonError("Client unregistration failed") + raise libjamiCtrlDeamonError("Client unregistration failed") def isRegistered(self): return self.registered @@ -330,7 +330,7 @@ class DRingCtrl(Thread): def _valid_account(self, account): account = account or self.account if account is None: - raise DRingCtrlError("No provided or current account!") + raise libjamiCtrlError("No provided or current account!") return account def isAccountExists(self, account): @@ -407,7 +407,7 @@ class DRingCtrl(Thread): """ if details is None: - raise DRingCtrlAccountError("Must specifies type, alias, hostname, \ + raise libjamiCtrlAccountError("Must specifies type, alias, hostname, \ username and password in \ order to create a new account") @@ -417,7 +417,7 @@ class DRingCtrl(Thread): """Remove an account from internal list""" if accountID is None: - raise DRingCtrlAccountError("Account ID must be specified") + raise libjamiCtrlAccountError("Account ID must be specified") self.configurationmanager.removeAccount(accountID) @@ -430,7 +430,7 @@ class DRingCtrl(Thread): details['Account.alias'] == alias): self.account = testedaccount return - raise DRingCtrlAccountError("No enabled account matched with alias") + raise libjamiCtrlAccountError("No enabled account matched with alias") def getAccountByAlias(self, alias): """Get account name having its alias""" @@ -440,7 +440,7 @@ class DRingCtrl(Thread): if details['Account.alias'] == alias: return account - raise DRingCtrlAccountError("No account matched with alias") + raise libjamiCtrlAccountError("No account matched with alias") def setAccount(self, account): """Define the active account @@ -452,14 +452,14 @@ class DRingCtrl(Thread): self.account = account else: print(account) - raise DRingCtrlAccountError("Not a valid account") + raise libjamiCtrlAccountError("Not a valid account") def setFirstRegisteredAccount(self): """Find the first enabled account and define it as active""" rAccounts = self.getAllRegisteredAccounts() if 0 == len(rAccounts): - raise DRingCtrlAccountError("No registered account !") + raise libjamiCtrlAccountError("No registered account !") self.account = rAccounts[0] def setFirstActiveAccount(self): @@ -467,7 +467,7 @@ class DRingCtrl(Thread): aAccounts = self.getAllEnabledAccounts() if 0 == len(aAccounts): - raise DRingCtrlAccountError("No active account !") + raise libjamiCtrlAccountError("No active account !") self.account = aAccounts[0] def getAccount(self): @@ -565,14 +565,14 @@ class DRingCtrl(Thread): """ if dest is None or dest == "": - raise DRingCtrlError("Invalid call destination") + raise libjamiCtrlError("Invalid call destination") # Set the account to be used for this call if not self.account: self.setFirstRegisteredAccount() if self.account != "IP2IP" and not self.isAccountRegistered(): - raise DRingCtrlAccountError("Can't place a call without a registered account") + raise libjamiCtrlAccountError("Can't place a call without a registered account") # Send the request to the CallManager callid = self.callmanager.placeCall(self.account, dest) @@ -599,7 +599,7 @@ class DRingCtrl(Thread): """Transfert a call identified by a CallID""" if callid is None or callid == "": - raise DRingCtrlError("Invalid callID") + raise libjamiCtrlError("Invalid callID") self.callmanager.transfert(callid, to) @@ -609,7 +609,7 @@ class DRingCtrl(Thread): print("Refuse call " + callid) if callid is None or callid == "": - raise DRingCtrlError("Invalid callID") + raise libjamiCtrlError("Invalid callID") self.callmanager.refuse(callid) @@ -622,10 +622,10 @@ class DRingCtrl(Thread): self.setFirstRegisteredAccount() if not self.isAccountRegistered(): - raise DRingCtrlAccountError("Can't accept a call without a registered account") + raise libjamiCtrlAccountError("Can't accept a call without a registered account") if callid is None or callid == "": - raise DRingCtrlError("Invalid callID") + raise libjamiCtrlError("Invalid callID") self.callmanager.accept(callid) @@ -634,7 +634,7 @@ class DRingCtrl(Thread): """Hold a call identified by a CallID""" if callid is None or callid == "": - raise DRingCtrlError("Invalid callID") + raise libjamiCtrlError("Invalid callID") self.callmanager.hold(callid) @@ -643,7 +643,7 @@ class DRingCtrl(Thread): """Unhold an incoming call identified by a CallID""" if callid is None or callid == "": - raise DRingCtrlError("Invalid callID") + raise libjamiCtrlError("Invalid callID") self.callmanager.unhold(callid) diff --git a/tools/jamictrl/errorsDring.py b/tools/jamictrl/errorsDring.py index f5c2cc7a7..6ef435ff2 100644 --- a/tools/jamictrl/errorsDring.py +++ b/tools/jamictrl/errorsDring.py @@ -21,7 +21,7 @@ """Internal exceptions""" -class DRingCtrlError(Exception): +class libjamiCtrlError(Exception): """Base class for all our exceptions.""" def __init__(self, help=None): @@ -30,11 +30,11 @@ class DRingCtrlError(Exception): def __str__(self): return self.help -class DRingCtrlDBusError(DRingCtrlError): +class libjamiCtrlDBusError(libjamiCtrlError): """General error for dbus communication""" -class DRingCtrlDeamonError(DRingCtrlError): +class libjamiCtrlDeamonError(libjamiCtrlError): """General error for daemon communication""" -class DRingCtrlAccountError(DRingCtrlError): +class libjamiCtrlAccountError(libjamiCtrlError): """General error for account handling""" diff --git a/tools/jamictrl/jami_test.py b/tools/jamictrl/jami_test.py index 175666a3b..cade47d45 100755 --- a/tools/jamictrl/jami_test.py +++ b/tools/jamictrl/jami_test.py @@ -26,10 +26,10 @@ import time import argparse from gi.repository import GLib -from errorsDring import DRingCtrlError -from controller import DRingCtrl +from errorsDring import libjamiCtrlError +from controller import libjamiCtrl -class JamiTest(DRingCtrl): +class JamiTest(libjamiCtrl): def __init__(self, name, args): super(JamiTest, self).__init__(name, False) self.args = args @@ -48,13 +48,13 @@ class JamiTest(DRingCtrl): volatileCallerDetails = self.getVolatileAccountDetails(self.account) if volatileCallerDetails['Account.registrationStatus'] != 'REGISTERED': - raise DRingCtrlError("Caller Account not registered") + raise libjamiCtrlError("Caller Account not registered") self.peer = args.peer volatilePeerDetails = self.getVolatileAccountDetails() if volatilePeerDetails['Account.registrationStatus'] != 'REGISTERED': - raise DRingCtrlError("Peer Account not registered") + raise libjamiCtrlError("Peer Account not registered") print("Using local test account: ", self.account, volatileCallerDetails['Account.registrationStatus']) print("Using test peer: ", self.peer, volatilePeerDetails['Account.registrationStatus']) diff --git a/tools/jamictrl/jamictrl.py b/tools/jamictrl/jamictrl.py index 74df28934..497e3ebb2 100755 --- a/tools/jamictrl/jamictrl.py +++ b/tools/jamictrl/jamictrl.py @@ -33,8 +33,8 @@ except Exception as e: exit(1) -from controller import DRingCtrl -from tester import DRingTester +from controller import libjamiCtrl +from tester import libjamiTester if __name__ == "__main__": parser = argparse.ArgumentParser() @@ -102,12 +102,12 @@ if __name__ == "__main__": parser.add_argument('--dtmf', help='Send DTMF', metavar='') parser.add_argument('--toggle-video', help='Launch toggle video tests', action='store_true') - parser.add_argument('--test', help=' '.join(str(test) for test in DRingTester().getTestName() ), metavar='') + parser.add_argument('--test', help=' '.join(str(test) for test in libjamiTester().getTestName() ), metavar='') parser.add_argument('--auto-answer', help='Keep running and auto-answer the calls', action='store_true') args = parser.parse_args() - ctrl = DRingCtrl(sys.argv[0], args.auto_answer) + ctrl = libjamiCtrl(sys.argv[0], args.auto_answer) if args.add_ring_account: accDetails = {'Account.type':'RING', 'Account.alias':args.add_ring_account if args.add_ring_account!='' else 'RingAccount'} @@ -224,7 +224,7 @@ if __name__ == "__main__": ctrl.Dtmf(args.dtmf) if args.test: - DRingTester().start(ctrl, args.test) + libjamiTester().start(ctrl, args.test) if args.toggle_video: if not ctrl.videomanager: diff --git a/tools/jamictrl/sendfile.py b/tools/jamictrl/sendfile.py index 50440875d..10cfcc8cc 100644 --- a/tools/jamictrl/sendfile.py +++ b/tools/jamictrl/sendfile.py @@ -17,14 +17,14 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -from controller import DRingCtrl +from controller import libjamiCtrl import argparse import sys import signal import os.path -class Controller(DRingCtrl): +class Controller(libjamiCtrl): def onDataTransferEvent(self, transferId, code): if code == 6: print("transfer %u has been cancelled by host" % transferId) diff --git a/tools/jamictrl/swarm.py b/tools/jamictrl/swarm.py index e3bc5c700..2679736dc 100644 --- a/tools/jamictrl/swarm.py +++ b/tools/jamictrl/swarm.py @@ -18,7 +18,7 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -from controller import DRingCtrl +from controller import libjamiCtrl import argparse import sys @@ -31,7 +31,7 @@ parser.add_argument('--account', help='Account to use', metavar='', typ args = parser.parse_args() -ctrl = DRingCtrl(sys.argv[0], False) +ctrl = libjamiCtrl(sys.argv[0], False) if not args.account: for account in ctrl.getAllEnabledAccounts(): details = ctrl.getAccountDetails(account) diff --git a/tools/jamictrl/test_jami_dbus_interface.py b/tools/jamictrl/test_jami_dbus_interface.py index 4d969c9e1..8c31707e8 100644 --- a/tools/jamictrl/test_jami_dbus_interface.py +++ b/tools/jamictrl/test_jami_dbus_interface.py @@ -25,7 +25,7 @@ import logging import multiprocessing from sippwrap import SippWrapper from sippwrap import SippScreenStatParser -from jamictrl import DRingCtrl as SflPhoneCtrl +from jamictrl import libjamiCtrl as SflPhoneCtrl from nose.tools import nottest diff --git a/tools/jamictrl/tester.py b/tools/jamictrl/tester.py index 6a346a471..19b607788 100644 --- a/tools/jamictrl/tester.py +++ b/tools/jamictrl/tester.py @@ -41,7 +41,7 @@ ALL_TEST_NAME = { 'DhtCallHold' : 'testLoopCallDhtWithHold' } -class DRingTester(): +class libjamiTester(): # init to default values dhtAccountId = '' diff --git a/tools/jamictrl/toggle_video_preview.py b/tools/jamictrl/toggle_video_preview.py index 2c65e0c87..8e49b4e1c 100755 --- a/tools/jamictrl/toggle_video_preview.py +++ b/tools/jamictrl/toggle_video_preview.py @@ -25,7 +25,7 @@ import sys import os from random import randint -class DRingToggleVideo(): +class libjamiToggleVideo(): def start(self): bus = dbus.SessionBus()