- Fix friends list subscription

- Search : Allow to change source and aggregation mode from Ui

Linphone/core/friend/FriendCore.cpp

@@ -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]() {

Linphone/core/search/MagicSearchList.cpp

@@ -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 =
+		mMagicSearch->mSourceFlags = mSourceFlags;
-		    (int)linphone::MagicSearch::Source::Friends | (int)linphone::MagicSearch::Source::LdapServers;
+		mMagicSearch->mAggregationFlag = mAggregationFlag;
-		mMagicSearch->mAggregationFlag = linphone::MagicSearch::Aggregation::Friend;
 		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();

Linphone/core/search/MagicSearchList.hpp

@@ -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;

Linphone/core/search/MagicSearchProxy.cpp

@@ -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);
+}

Linphone/core/search/MagicSearchProxy.hpp

@@ -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;

Linphone/model/core/CoreModel.cpp

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

Linphone/model/friend/FriendModel.cpp

@@ -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)

Linphone/model/search/MagicSearchModel.cpp

@@ -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) {

Linphone/model/search/MagicSearchModel.hpp

@@ -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
 

Linphone/tool/LinphoneEnums.cpp

@@ -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:

Linphone/tool/LinphoneEnums.hpp

@@ -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);