mirrors/linphone-desktop
1
0
Fork 0
mirror of https://gitlab.linphone.org/BC/public/linphone-desktop.git synced 2026-01-17 11:28:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

- Fix friends list subscription

Browse source 
- Search : Allow to change source and aggregation mode from Ui
This commit is contained in:
Julien Wadel 2023-11-29 16:23:18 +01:00
parent bf99675d08
commit 41ee79c070
11 changed files with 125 additions and 7 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Linphone/core/friend/FriendCore.cpp
View file

@ -191,6 +191,7 @@ void FriendCore::save() { // Save Value
if (created) {
mFriendModel = Utils::makeQObject_ptr<FriendModel>(contact);
mFriendModel->setSelf(mFriendModel);
core->getDefaultFriendList()->updateSubscriptions();
}
emit CoreModel::getInstance()->friendAdded();
mFriendModelConnection->invokeToCore([this, created]() {

40
Linphone/core/search/MagicSearchList.cpp
View file

@ -39,14 +39,15 @@ QSharedPointer<MagicSearchList> MagicSearchList::create() {
MagicSearchList::MagicSearchList(QObject *parent) : ListProxy(parent) {
mustBeInMainThread(getClassName());
mSourceFlags = (int)linphone::MagicSearch::Source::Friends | (int)linphone::MagicSearch::Source::LdapServers;
mAggregationFlag = LinphoneEnums::MagicSearchAggregation::Friend;
App::postModelSync([this]() {
mustBeInLinphoneThread(log().arg(Q_FUNC_INFO));
auto linphoneSearch = CoreModel::getInstance()->getCore()->createMagicSearch();
linphoneSearch->setLimitedSearch(false);
mMagicSearch = Utils::makeQObject_ptr<MagicSearchModel>(linphoneSearch);
mMagicSearch->mSourceFlags =
(int)linphone::MagicSearch::Source::Friends | (int)linphone::MagicSearch::Source::LdapServers;
mMagicSearch->mAggregationFlag = linphone::MagicSearch::Aggregation::Friend;
mMagicSearch->mSourceFlags = mSourceFlags;
mMagicSearch->mAggregationFlag = mAggregationFlag;
mMagicSearch->setSelf(mMagicSearch);
});
}
@ -62,6 +63,17 @@ void MagicSearchList::setSelf(QSharedPointer<MagicSearchList> me) {
mModelConnection->makeConnect(this, &MagicSearchList::lSearch, [this](QString filter) {
mModelConnection->invokeToModel([this, filter]() { mMagicSearch->search(filter); });
});
mModelConnection->makeConnect(this, &MagicSearchList::lSetSourceFlags, [this](int flags) {
mModelConnection->invokeToModel([this, flags]() { mMagicSearch->setSourceFlags(flags); });
});
mModelConnection->makeConnect(mMagicSearch.get(), &MagicSearchModel::sourceFlagsChanged, [this](int flags) {
mModelConnection->invokeToCore([this, flags]() { setSourceFlags(flags); });
});
mModelConnection->makeConnect(mMagicSearch.get(), &MagicSearchModel::aggregationFlagChanged,
[this](LinphoneEnums::MagicSearchAggregation flag) {
mModelConnection->invokeToCore([this, flag]() { setAggregationFlag(flag); });
});
mModelConnection->makeConnect(mMagicSearch.get(), &MagicSearchModel::searchResultsReceived,
[this](const std::list<std::shared_ptr<linphone::SearchResult>> &results) {
auto *contacts = new QList<QSharedPointer<FriendCore>>();
@ -97,6 +109,28 @@ void MagicSearchList::setSearch(const QString &search) {
}
}
int MagicSearchList::getSourceFlags() const {
return mSourceFlags;
}
void MagicSearchList::setSourceFlags(int flags) {
if (mSourceFlags != flags) {
mSourceFlags = flags;
emit sourceFlagsChanged(mSourceFlags);
}
}
LinphoneEnums::MagicSearchAggregation MagicSearchList::getAggregationFlag() const {
return mAggregationFlag;
}
void MagicSearchList::setAggregationFlag(LinphoneEnums::MagicSearchAggregation flags) {
if (mAggregationFlag != flags) {
mAggregationFlag = flags;
emit aggregationFlagChanged(mAggregationFlag);
}
}
QVariant MagicSearchList::data(const QModelIndex &index, int role) const {
int row = index.row();
if (!index.isValid() || row < 0 || row >= mList.count()) return QVariant();

14
Linphone/core/search/MagicSearchList.hpp
View file

@ -42,12 +42,26 @@ public:
void setSearch(const QString &search);
void setResults(const QList<QSharedPointer<FriendCore>> &contacts);
int getSourceFlags() const;
void setSourceFlags(int flags);
LinphoneEnums::MagicSearchAggregation getAggregationFlag() const;
void setAggregationFlag(LinphoneEnums::MagicSearchAggregation flag);
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
signals:
void lSearch(QString filter);
void lSetSourceFlags(int sourceFlags);
void lSetAggregationFlag(LinphoneEnums::MagicSearchAggregation aggregationFlag);
void sourceFlagsChanged(int sourceFlags);
void aggregationFlagChanged(LinphoneEnums::MagicSearchAggregation flag);
private:
int mSourceFlags;
LinphoneEnums::MagicSearchAggregation mAggregationFlag;
std::shared_ptr<MagicSearchModel> mMagicSearch;
QSharedPointer<SafeConnection> mModelConnection;
QSharedPointer<SafeConnection> mCoreModelConnection;

18
Linphone/core/search/MagicSearchProxy.cpp
View file

@ -23,6 +23,8 @@
MagicSearchProxy::MagicSearchProxy(QObject *parent) : SortFilterProxy(parent) {
mList = MagicSearchList::create();
connect(mList.get(), &MagicSearchList::sourceFlagsChanged, this, &MagicSearchProxy::sourceFlagsChanged);
connect(mList.get(), &MagicSearchList::aggregationFlagChanged, this, &MagicSearchProxy::aggregationFlagChanged);
setSourceModel(mList.get());
sort(0);
}
@ -38,3 +40,19 @@ void MagicSearchProxy::setSearchText(const QString &search) {
mSearchText = search;
qobject_cast<MagicSearchList *>(sourceModel())->setSearch(mSearchText);
}
int MagicSearchProxy::getSourceFlags() const {
return qobject_cast<MagicSearchList *>(sourceModel())->getSourceFlags();
}
void MagicSearchProxy::setSourceFlags(int flags) {
qobject_cast<MagicSearchList *>(sourceModel())->lSetSourceFlags(flags);
}
LinphoneEnums::MagicSearchAggregation MagicSearchProxy::getAggregationFlag() const {
return qobject_cast<MagicSearchList *>(sourceModel())->getAggregationFlag();
}
void MagicSearchProxy::setAggregationFlag(LinphoneEnums::MagicSearchAggregation flag) {
qobject_cast<MagicSearchList *>(sourceModel())->lSetAggregationFlag(flag);
}

12
Linphone/core/search/MagicSearchProxy.hpp
View file

@ -23,6 +23,7 @@
#include "../proxy/SortFilterProxy.hpp"
#include "core/search/MagicSearchList.hpp"
#include "tool/LinphoneEnums.hpp"
// =============================================================================
@ -30,6 +31,9 @@ class MagicSearchProxy : public SortFilterProxy {
Q_OBJECT
Q_PROPERTY(QString searchText READ getSearchText WRITE setSearchText NOTIFY searchTextChanged)
Q_PROPERTY(int sourceFlags READ getSourceFlags WRITE setSourceFlags NOTIFY sourceFlagsChanged)
Q_PROPERTY(LinphoneEnums::MagicSearchAggregation aggregationFlag READ getAggregationFlag WRITE setAggregationFlag
NOTIFY aggregationFlagChanged)
public:
MagicSearchProxy(QObject *parent = Q_NULLPTR);
@ -38,8 +42,16 @@ public:
QString getSearchText() const;
void setSearchText(const QString &search);
int getSourceFlags() const;
void setSourceFlags(int flags);
LinphoneEnums::MagicSearchAggregation getAggregationFlag() const;
void setAggregationFlag(LinphoneEnums::MagicSearchAggregation flag);
signals:
void searchTextChanged();
void sourceFlagsChanged(int sourceFlags);
void aggregationFlagChanged(LinphoneEnums::MagicSearchAggregation aggregationFlag);
protected:
QString mSearchText;

2
Linphone/model/core/CoreModel.cpp
View file

@ -72,6 +72,8 @@ void CoreModel::start() {
setPathsAfterCreation();
mCore->start();
setPathAfterStart();
mCore->enableFriendListSubscription(true);
mCore->enableRecordAware(true);
mIterateTimer->start();
}
// -----------------------------------------------------------------------------

2
Linphone/model/friend/FriendModel.cpp
View file

@ -22,8 +22,6 @@
#include <QDebug>
#include "model/core/CoreModel.hpp"
DEFINE_ABSTRACT_OBJECT(FriendModel)
FriendModel::FriendModel(const std::shared_ptr<linphone::Friend> &contact, QObject *parent)

18
Linphone/model/search/MagicSearchModel.cpp
View file

@ -45,7 +45,23 @@ void MagicSearchModel::search(QString filter) {
mustBeInLinphoneThread(log().arg(Q_FUNC_INFO));
mLastSearch = filter;
mMonitor->getContactsListAsync(filter != "*" ? Utils::appStringToCoreString(filter) : "", "", mSourceFlags,
mAggregationFlag);
LinphoneEnums::toLinphone(mAggregationFlag));
}
void MagicSearchModel::setSourceFlags(int flags) {
mustBeInLinphoneThread(log().arg(Q_FUNC_INFO));
if (mSourceFlags != flags) {
mSourceFlags = flags;
emit sourceFlagsChanged(mSourceFlags);
}
}
void MagicSearchModel::setAggregationFlag(LinphoneEnums::MagicSearchAggregation flag) {
mustBeInLinphoneThread(log().arg(Q_FUNC_INFO));
if (mAggregationFlag != flag) {
mAggregationFlag = flag;
emit aggregationFlagChanged(mAggregationFlag);
}
}
void MagicSearchModel::onSearchResultsReceived(const std::shared_ptr<linphone::MagicSearch> &magicSearch) {

9
Linphone/model/search/MagicSearchModel.hpp
View file

@ -23,6 +23,7 @@
#include "model/listener/Listener.hpp"
#include "tool/AbstractObject.hpp"
#include "tool/LinphoneEnums.hpp"
#include <QObject>
#include <QTimer>
@ -37,11 +38,17 @@ public:
~MagicSearchModel();
void search(QString filter);
void setSourceFlags(int flags);
void setAggregationFlag(LinphoneEnums::MagicSearchAggregation flag);
int mSourceFlags = (int)linphone::MagicSearch::Source::All;
linphone::MagicSearch::Aggregation mAggregationFlag = linphone::MagicSearch::Aggregation::None;
LinphoneEnums::MagicSearchAggregation mAggregationFlag = LinphoneEnums::MagicSearchAggregation::None;
QString mLastSearch;
signals:
void sourceFlagsChanged(int sourceFlags);
void aggregationFlagChanged(LinphoneEnums::MagicSearchAggregation aggregationFlag);
private:
DECLARE_ABSTRACT_OBJECT

7
Linphone/tool/LinphoneEnums.cpp
View file

@ -147,6 +147,13 @@ LinphoneEnums::ConsolidatedPresence LinphoneEnums::fromLinphone(const linphone::
return static_cast<LinphoneEnums::ConsolidatedPresence>(data);
}
linphone::MagicSearch::Aggregation LinphoneEnums::toLinphone(const LinphoneEnums::MagicSearchAggregation &data) {
return static_cast<linphone::MagicSearch::Aggregation>(data);
}
LinphoneEnums::MagicSearchAggregation LinphoneEnums::fromLinphone(const linphone::MagicSearch::Aggregation &data) {
return static_cast<LinphoneEnums::MagicSearchAggregation>(data);
}
linphone::LogLevel LinphoneEnums::toLinphone(const QtMsgType &data) {
switch (data) {
case QtDebugMsg:

9
Linphone/tool/LinphoneEnums.hpp
View file

@ -202,6 +202,15 @@ Q_ENUM_NS(ConsolidatedPresence);
linphone::ConsolidatedPresence toLinphone(const LinphoneEnums::ConsolidatedPresence &state);
LinphoneEnums::ConsolidatedPresence fromLinphone(const linphone::ConsolidatedPresence &state);
enum class MagicSearchAggregation {
Friend = int(linphone::MagicSearch::Aggregation::Friend),
None = int(linphone::MagicSearch::Aggregation::None)
};
Q_ENUM_NS(MagicSearchAggregation);
linphone::MagicSearch::Aggregation toLinphone(const LinphoneEnums::MagicSearchAggregation &data);
LinphoneEnums::MagicSearchAggregation fromLinphone(const linphone::MagicSearch::Aggregation &data);
linphone::LogLevel toLinphone(const QtMsgType &data);
QtMsgType fromLinphone(const linphone::LogLevel &data);