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

Update enums to SDK master's wrapper.

Browse source
This commit is contained in:
Julien Wadel 2023-02-23 11:16:20 +01:00
parent ea7c02a335
commit 53caefb7e5
22 changed files with 94 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
linphone-app/src/components/call/CallModel.cpp
View file

@ -124,7 +124,7 @@ CallModel::CallModel (shared_ptr<linphone::Call> call){
if( conferenceInfo ){
mConferenceInfoModel = ConferenceInfoModel::create(conferenceInfo);
}
mMagicSearch->getContactsListAsync(mRemoteAddress->getUsername(),mRemoteAddress->getDomain(), (int)linphone::MagicSearchSource::LdapServers | (int)linphone::MagicSearchSource::Friends, linphone::MagicSearchAggregation::Friend);
mMagicSearch->getContactsListAsync(mRemoteAddress->getUsername(),mRemoteAddress->getDomain(), (int)linphone::MagicSearch::Source::LdapServers | (int)linphone::MagicSearch::Source::Friends, linphone::MagicSearch::Aggregation::Friend);
}
}
@ -214,7 +214,7 @@ ChatRoomModel * CallModel::getChatRoomModel(){
params->enableGroup(false);
participants.push_back(mCall->getRemoteAddress()->clone());
}
if( params->getSubject() == "") // A linphone::ChatRoomBackend::FlexisipChat need a subject.
if( params->getSubject() == "") // A linphone::ChatRoom::Backend::FlexisipChat need a subject.
params->setSubject("Dummy Subject");
mChatRoom = core->searchChatRoom(params, callLocalAddress
@ -959,7 +959,7 @@ void CallModel::searchReceived(std::list<std::shared_ptr<linphone::SearchResult>
std::string newDisplayName = (*it)->getAddress()->getDisplayName();
if(!newDisplayName.empty()){
// LDAP friend
if( ((*it)->getSourceFlags() & (int) linphone::MagicSearchSource::LdapServers) == (int) linphone::MagicSearchSource::LdapServers){
if( ((*it)->getSourceFlags() & (int) linphone::MagicSearch::Source::LdapServers) == (int) linphone::MagicSearch::Source::LdapServers){
setRemoteDisplayName(newDisplayName);
found = true;
}else if( Utils::coreStringToAppString(mRemoteAddress->getDisplayName()).isEmpty()){
@ -1073,7 +1073,7 @@ void CallModel::updateConferenceVideoLayout(){
newLayout = LinphoneEnums::ConferenceLayoutAudioOnly;
if( mConferenceVideoLayout != newLayout && !getPausedByUser()){// Only update if not in pause.
if(mCall->getConference()){
if( callParams->getConferenceVideoLayout() == linphone::ConferenceLayout::Grid)
if( callParams->getConferenceVideoLayout() == linphone::Conference::Layout::Grid)
settings->setCameraMode(settings->getGridCameraMode());
else
settings->setCameraMode(settings->getActiveSpeakerCameraMode());
@ -1207,10 +1207,10 @@ void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callSt
QString family;
switch (callStats->getIpFamilyOfRemote()) {
case linphone::AddressFamily::Inet:
case linphone::Address::Family::Inet:
family = QStringLiteral("IPv4");
break;
case linphone::AddressFamily::Inet6:
case linphone::Address::Family::Inet6:
family = QStringLiteral("IPv6");
break;
default:

6
linphone-app/src/components/calls/CallsListModel.cpp
View file

@ -186,7 +186,7 @@ void CallsListModel::launchVideoCall (const QString &sipAddress, const QString&
shared_ptr<linphone::CallParams> params = core->createCallParams(nullptr);
auto layout = options.contains("layout") ? LinphoneEnums::toLinphone((LinphoneEnums::ConferenceLayout)options["layout"].toInt()) : linphone::ConferenceLayout::Grid;
auto layout = options.contains("layout") ? LinphoneEnums::toLinphone((LinphoneEnums::ConferenceLayout)options["layout"].toInt()) : linphone::Conference::Layout::Grid;
bool enableMicro =options.contains("micro") ? options["micro"].toBool() : true;
bool enableVideo = options.contains("video") ? options["video"].toBool() : true;
bool enableCamera = options.contains("camera") ? options["camera"].toBool() : true;
@ -224,7 +224,7 @@ ChatRoomModel* CallsListModel::createChat (const QString &participantAddress) co
std::shared_ptr<const linphone::Address> localAddress;
participants.push_back(address);
params->setBackend(linphone::ChatRoomBackend::Basic);
params->setBackend(linphone::ChatRoom::Backend::Basic);
qInfo() << "Create ChatRoom with " <<participantAddress;
std::shared_ptr<linphone::ChatRoom> chatRoom = core->createChatRoom(params, localAddress, participants);
@ -316,7 +316,7 @@ QVariantMap CallsListModel::createChatRoom(const QString& subject, const int& se
params->enableEncryption(securityLevel>0);
if( securityLevel<=0)
params->setBackend(linphone::ChatRoomBackend::Basic);
params->setBackend(linphone::ChatRoom::Backend::Basic);
params->enableGroup( subject!="" );

14
linphone-app/src/components/chat-room/ChatRoomModel.cpp
View file

@ -316,7 +316,7 @@ QString ChatRoomModel::getFullLocalAddress () const {
}
QString ChatRoomModel::getConferenceAddress () const {
if(!mChatRoom || mChatRoom->hasCapability((int)linphone::ChatRoomCapabilities::Basic))
if(!mChatRoom || mChatRoom->hasCapability((int)linphone::ChatRoom::Capabilities::Basic))
return "";
else {
auto address = mChatRoom->getConferenceAddress();
@ -435,7 +435,7 @@ bool ChatRoomModel::canBeEphemeral(){
}
bool ChatRoomModel::haveEncryption() const{
return mChatRoom && mChatRoom->getCurrentParams()->getEncryptionBackend() != linphone::ChatRoomEncryptionBackend::None;
return mChatRoom && mChatRoom->getCurrentParams()->getEncryptionBackend() != linphone::ChatRoom::EncryptionBackend::None;
}
bool ChatRoomModel::haveConferenceAddress() const{
@ -447,8 +447,8 @@ bool ChatRoomModel::markAsReadEnabled() const{
}
bool ChatRoomModel::isSecure() const{
return mChatRoom && (mChatRoom->getSecurityLevel() == linphone::ChatRoomSecurityLevel::Encrypted
|| mChatRoom->getSecurityLevel() == linphone::ChatRoomSecurityLevel::Safe);
return mChatRoom && (mChatRoom->getSecurityLevel() == linphone::ChatRoom::SecurityLevel::Encrypted
|| mChatRoom->getSecurityLevel() == linphone::ChatRoom::SecurityLevel::Safe);
}
int ChatRoomModel::getSecurityLevel() const{
@ -460,11 +460,11 @@ bool ChatRoomModel::isGroupEnabled() const{
}
bool ChatRoomModel::isConference() const{
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoomCapabilities::Conference);
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoom::Capabilities::Conference);
}
bool ChatRoomModel::isOneToOne() const{
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoomCapabilities::OneToOne);
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoom::Capabilities::OneToOne);
}
bool ChatRoomModel::isMeAdmin() const{
@ -488,7 +488,7 @@ bool ChatRoomModel::isEntriesLoading() const{
}
bool ChatRoomModel::isBasic() const{
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoomCapabilities::Basic);
return mChatRoom && mChatRoom->hasCapability((int)linphone::ChatRoom::Capabilities::Basic);
}
bool ChatRoomModel::isUpdating() const{

2
linphone-app/src/components/conference/ConferenceListener.cpp
View file

@ -67,7 +67,7 @@ void ConferenceListener::onParticipantDeviceRemoved(const std::shared_ptr<linpho
qDebug() << "Me devices : " << conference->getMe()->getDevices().size();
emit participantDeviceRemoved(participantDevice);
}
void ConferenceListener::onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state) {
void ConferenceListener::onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state) {
qDebug() << "onParticipantDeviceStateChanged: " << device->getAddress()->asString().c_str() << " isInConf?[" << device->isInConference() << "] " << (int)state;
emit participantDeviceStateChanged(conference, device, state);
}

4
linphone-app/src/components/conference/ConferenceListener.hpp
View file

@ -41,7 +41,7 @@ public:
virtual void onParticipantAdminStatusChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::Participant> & participant) override;
virtual void onParticipantDeviceAdded(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice) override;
virtual void onParticipantDeviceRemoved(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice) override;
virtual void onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state) override;
virtual void onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state) override;
virtual void onParticipantDeviceMediaCapabilityChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device) override;
virtual void onParticipantDeviceMediaAvailabilityChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device) override;
virtual void onParticipantDeviceIsSpeakingChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice, bool isSpeaking) override;
@ -57,7 +57,7 @@ signals:
void participantAdminStatusChanged(const std::shared_ptr<const linphone::Participant> & participant);
void participantDeviceAdded(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceRemoved(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state);
void participantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state);
void participantDeviceMediaCapabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceMediaAvailabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceIsSpeakingChanged(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice, bool isSpeaking);

2
linphone-app/src/components/conference/ConferenceModel.cpp
View file

@ -165,7 +165,7 @@ void ConferenceModel::onParticipantDeviceRemoved(const std::shared_ptr<const lin
emit participantDeviceRemoved(participantDevice);
}
void ConferenceModel::onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state){
void ConferenceModel::onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state){
qDebug() << "Me devices : " << mConference->getMe()->getDevices().size();
updateLocalParticipant();
emit participantDeviceStateChanged(device, state);

4
linphone-app/src/components/conference/ConferenceModel.hpp
View file

@ -71,7 +71,7 @@ public:
virtual void onParticipantDeviceMediaCapabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device);
virtual void onParticipantDeviceMediaAvailabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device);
virtual void onParticipantDeviceIsSpeakingChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device, bool isSpeaking);
virtual void onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state);
virtual void onParticipantDeviceStateChanged(const std::shared_ptr<linphone::Conference> & conference, const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state);
virtual void onConferenceStateChanged(linphone::Conference::State newState);
virtual void onSubjectChanged(const std::string& subject);
//---------------------------------------------------------------------------
@ -87,7 +87,7 @@ signals:
void participantDeviceMediaCapabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceMediaAvailabilityChanged(const std::shared_ptr<const linphone::ParticipantDevice> & participantDevice);
void participantDeviceIsSpeakingChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device, bool isSpeaking);
void participantDeviceStateChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDeviceState state);
void participantDeviceStateChanged(const std::shared_ptr<const linphone::ParticipantDevice> & device, linphone::ParticipantDevice::State state);
void conferenceStateChanged(linphone::Conference::State newState);
void subjectChanged();
void isReadyChanged();

8
linphone-app/src/components/core/CoreHandlers.cpp
View file

@ -141,11 +141,11 @@ void CoreHandlers::onChatRoomStateChanged(
void CoreHandlers::onConfiguringStatus(
const std::shared_ptr<linphone::Core> & core,
linphone::ConfiguringState status,
linphone::Config::ConfiguringState status,
const std::string & message){
Q_UNUSED(core)
emit setLastRemoteProvisioningState(status);
if(status == linphone::ConfiguringState::Failed){
if(status == linphone::Config::ConfiguringState::Failed){
qWarning() << "Remote provisioning has failed and was removed : "<< QString::fromStdString(message);
core->setProvisioningUri("");
}
@ -233,8 +233,8 @@ void CoreHandlers::onMessagesReceived (
if( !message || message->isOutgoing() )
continue;
// 1. Do not notify if chat is not activated.
if (chatRoom->getCurrentParams()->getEncryptionBackend() == linphone::ChatRoomEncryptionBackend::None && !settingsModel->getStandardChatEnabled()
|| chatRoom->getCurrentParams()->getEncryptionBackend() != linphone::ChatRoomEncryptionBackend::None && !settingsModel->getSecureChatEnabled())
if (chatRoom->getCurrentParams()->getEncryptionBackend() == linphone::ChatRoom::EncryptionBackend::None && !settingsModel->getStandardChatEnabled()
|| chatRoom->getCurrentParams()->getEncryptionBackend() != linphone::ChatRoom::EncryptionBackend::None && !settingsModel->getSecureChatEnabled())
continue;
messagesToSignal.push_back(message);

4
linphone-app/src/components/core/CoreHandlers.hpp
View file

@ -58,7 +58,7 @@ signals:
void presenceStatusReceived(std::shared_ptr<linphone::Friend> contact);
void registrationStateChanged (const std::shared_ptr<linphone::Account> &account, linphone::RegistrationState state);
void ecCalibrationResult(linphone::EcCalibratorStatus status, int delayMs);
void setLastRemoteProvisioningState(const linphone::ConfiguringState &state);
void setLastRemoteProvisioningState(const linphone::Config::ConfiguringState &state);
void conferenceInfoReceived(const std::shared_ptr<const linphone::ConferenceInfo> & conferenceInfo);
void foundQRCode(const std::string & result);
@ -115,7 +115,7 @@ private:
void onConfiguringStatus(
const std::shared_ptr<linphone::Core> & core,
linphone::ConfiguringState status,
linphone::Config::ConfiguringState status,
const std::string & message) override;
void onDtmfReceived(

6
linphone-app/src/components/core/CoreManager.cpp
View file

@ -69,7 +69,7 @@ CoreManager *CoreManager::mInstance=nullptr;
CoreManager::CoreManager (QObject *parent, const QString &configPath) :
QObject(parent), mHandlers(make_shared<CoreHandlers>(this)) {
mCore = nullptr;
mLastRemoteProvisioningState = linphone::ConfiguringState::Skipped;
mLastRemoteProvisioningState = linphone::Config::ConfiguringState::Skipped;
CoreHandlers *coreHandlers = mHandlers.get();
QObject::connect(coreHandlers, &CoreHandlers::coreStarting, this, &CoreManager::startIterate, Qt::QueuedConnection);
QObject::connect(coreHandlers, &CoreHandlers::setLastRemoteProvisioningState, this, &CoreManager::setLastRemoteProvisioningState);
@ -459,12 +459,12 @@ QString CoreManager::getDownloadUrl () {
return Constants::DownloadUrl;
}
void CoreManager::setLastRemoteProvisioningState(const linphone::ConfiguringState& state){
void CoreManager::setLastRemoteProvisioningState(const linphone::Config::ConfiguringState& state){
mLastRemoteProvisioningState = state;
}
bool CoreManager::isLastRemoteProvisioningGood(){
return mLastRemoteProvisioningState != linphone::ConfiguringState::Failed;
return mLastRemoteProvisioningState != linphone::Config::ConfiguringState::Failed;
}
QString CoreManager::getUserAgent()const {

4
linphone-app/src/components/core/CoreManager.hpp
View file

@ -178,7 +178,7 @@ public slots:
void initCoreManager();
void startIterate();
void stopIterate();
void setLastRemoteProvisioningState(const linphone::ConfiguringState& state);
void setLastRemoteProvisioningState(const linphone::Config::ConfiguringState& state);
void createLinphoneCore (const QString &configPath);// In order to delay creation
void handleChatRoomCreated(const QSharedPointer<ChatRoomModel> &chatRoomModel);
@ -218,7 +218,7 @@ private:
std::shared_ptr<CoreHandlers> mHandlers; // It is used for handling linphone. Keep it to shared_ptr.
bool mStarted = false;
linphone::ConfiguringState mLastRemoteProvisioningState;
linphone::Config::ConfiguringState mLastRemoteProvisioningState;
CallsListModel *mCallsListModel = nullptr;
ContactsListModel *mContactsListModel = nullptr;

4
linphone-app/src/components/ldap/LdapModel.cpp
View file

@ -112,8 +112,8 @@ void LdapModel::set(){
mLdapParams->setNameAttribute(mNameAttributes.toStdString());
mLdapParams->setSipAttribute(mSipAttributes.toStdString());
mLdapParams->setSipDomain(mSipDomain.toStdString());
mLdapParams->setDebugLevel( (linphone::LdapDebugLevel) mDebug);
mLdapParams->setServerCertificatesVerificationMode((linphone::LdapCertVerificationMode)mVerifyServerCertificates);
mLdapParams->setDebugLevel( (linphone::Ldap::DebugLevel) mDebug);
mLdapParams->setServerCertificatesVerificationMode((linphone::Ldap::CertVerificationMode)mVerifyServerCertificates);
}
void LdapModel::unset(){

2
linphone-app/src/components/participant/ParticipantDeviceListener.cpp
View file

@ -38,7 +38,7 @@ void ParticipantDeviceListener::onIsMuted(const std::shared_ptr<linphone::Partic
emit isMuted(participantDevice, isMutedVar);
}
void ParticipantDeviceListener::onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDeviceState state){
void ParticipantDeviceListener::onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDevice::State state){
qDebug() << "onStateChanged: " << participantDevice->getAddress()->asString().c_str() << " " << (int)state;
emit stateChanged(participantDevice, state);
}

4
linphone-app/src/components/participant/ParticipantDeviceListener.hpp
View file

@ -38,13 +38,13 @@ public:
virtual void onIsSpeakingChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isSpeaking) override;
virtual void onIsMuted(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isMuted) override;
virtual void onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDeviceState state) override;
virtual void onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDevice::State state) override;
virtual void onStreamCapabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::MediaDirection direction, linphone::StreamType streamType) override;
virtual void onStreamAvailabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool available, linphone::StreamType streamType) override;
signals:
void isSpeakingChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isSpeaking);
void isMuted(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isMuted);
void stateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDeviceState state);
void stateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDevice::State state);
void streamCapabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::MediaDirection direction, linphone::StreamType streamType);
void streamAvailabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool available, linphone::StreamType streamType);
};

20
linphone-app/src/components/participant/ParticipantDeviceModel.cpp
View file

@ -175,17 +175,17 @@ void ParticipantDeviceModel::onIsSpeakingChanged(const std::shared_ptr<linphone:
void ParticipantDeviceModel::onIsMuted(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isMuted) {
emit isMutedChanged();
}
void ParticipantDeviceModel::onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDeviceState state){
void ParticipantDeviceModel::onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDevice::State state){
switch(state){
case linphone::ParticipantDeviceState::Joining: break;
case linphone::ParticipantDeviceState::Present: setPaused(false);break;
case linphone::ParticipantDeviceState::Leaving: break;
case linphone::ParticipantDeviceState::Left: break;
case linphone::ParticipantDeviceState::ScheduledForJoining: break;
case linphone::ParticipantDeviceState::ScheduledForLeaving: break;
case linphone::ParticipantDeviceState::OnHold: setPaused(true);break;
case linphone::ParticipantDeviceState::Alerting: break;
case linphone::ParticipantDeviceState::MutedByFocus: break;
case linphone::ParticipantDevice::State::Joining: break;
case linphone::ParticipantDevice::State::Present: setPaused(false);break;
case linphone::ParticipantDevice::State::Leaving: break;
case linphone::ParticipantDevice::State::Left: break;
case linphone::ParticipantDevice::State::ScheduledForJoining: break;
case linphone::ParticipantDevice::State::ScheduledForLeaving: break;
case linphone::ParticipantDevice::State::OnHold: setPaused(true);break;
case linphone::ParticipantDevice::State::Alerting: break;
case linphone::ParticipantDevice::State::MutedByFocus: break;
default:{}
}
setState(LinphoneEnums::fromLinphone(state));

4
linphone-app/src/components/participant/ParticipantDeviceModel.hpp
View file

@ -76,7 +76,7 @@ public:
virtual void onIsSpeakingChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isSpeaking);
virtual void onIsMuted(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool isMuted);
virtual void onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDeviceState state);
virtual void onStateChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::ParticipantDevice::State state);
virtual void onStreamCapabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, linphone::MediaDirection direction, linphone::StreamType streamType);
virtual void onStreamAvailabilityChanged(const std::shared_ptr<linphone::ParticipantDevice> & participantDevice, bool available, linphone::StreamType streamType);
@ -100,7 +100,7 @@ private:
bool mIsVideoEnabled;
bool mIsPaused = false;
bool mIsSpeaking = false;
linphone::ParticipantDeviceState mState;
linphone::ParticipantDevice::State mState;
std::shared_ptr<linphone::ParticipantDevice> mParticipantDevice;
std::shared_ptr<ParticipantDeviceListener> mParticipantDeviceListener; // This is passed to linpĥone object and must be in shared_ptr

2
linphone-app/src/components/recorder/RecorderManager.cpp
View file

@ -45,7 +45,7 @@ RecorderModel* RecorderManager::getVocalRecorder(){
if( !mVocalRecorder) {
auto core = CoreManager::getInstance()->getCore();
std::shared_ptr<linphone::RecorderParams> params = core->createRecorderParams();
params->setFileFormat(linphone::RecorderFileFormat::Mkv);
params->setFileFormat(linphone::Recorder::FileFormat::Mkv);
params->setVideoCodec("");
auto recorder = core->createRecorder(params);
if(recorder)

4
linphone-app/src/components/recorder/RecorderModel.cpp
View file

@ -108,9 +108,9 @@ void RecorderModel::pause(){
}
void RecorderModel::stop(){
if(mRecorder->getState() == linphone::RecorderState::Running) // Remove these tests when the SDK do them.
if(mRecorder->getState() == linphone::Recorder::State::Running) // Remove these tests when the SDK do them.
mRecorder->pause();
if(mRecorder->getState() == linphone::RecorderState::Paused)
if(mRecorder->getState() == linphone::Recorder::State::Paused)
mRecorder->close();
emit stateChanged();
}

2
linphone-app/src/components/search/SearchSipAddressesModel.cpp
View file

@ -62,7 +62,7 @@ SearchSipAddressesModel::~SearchSipAddressesModel(){
// -----------------------------------------------------------------------------
void SearchSipAddressesModel::setFilter(const QString& filter){
mMagicSearch->getContactsListAsync(filter.toStdString(),"", (int)linphone::MagicSearchSource::All, linphone::MagicSearchAggregation::None);
mMagicSearch->getContactsListAsync(filter.toStdString(),"", (int)linphone::MagicSearch::Source::All, linphone::MagicSearch::Aggregation::None);
//searchReceived(mMagicSearch->getContactListFromFilter(Utils::appStringToCoreString(filter),"")); // Just to show how to use sync method
}

2
linphone-app/src/components/timeline/TimelineListModel.cpp
View file

@ -248,7 +248,7 @@ void TimelineListModel::updateTimelines () {
chatRoom->markAsRead();
if(chatRoom->getState() == linphone::ChatRoom::State::Deleted)
return true;
if(!chatRoom->hasCapability((int)linphone::ChatRoomCapabilities::Basic)){
if(!chatRoom->hasCapability((int)linphone::ChatRoom::Capabilities::Basic)){
auto conferenceAddress = chatRoom->getConferenceAddress();
if( conferenceAddress && conferenceAddress->getDomain() == Constants::LinphoneDomain) {
QString conferenceAddressStr = Utils::coreStringToAppString(conferenceAddress->asStringUriOnly());

26
linphone-app/src/utils/LinphoneEnums.cpp
View file

@ -62,10 +62,10 @@ LinphoneEnums::MediaEncryption LinphoneEnums::fromLinphone(const linphone::Media
return static_cast<LinphoneEnums::MediaEncryption>(data);
}
linphone::FriendCapability LinphoneEnums::toLinphone(const LinphoneEnums::FriendCapability& data){
return static_cast<linphone::FriendCapability>(data);
linphone::Friend::Capability LinphoneEnums::toLinphone(const LinphoneEnums::FriendCapability& data){
return static_cast<linphone::Friend::Capability>(data);
}
LinphoneEnums::FriendCapability LinphoneEnums::fromLinphone(const linphone::FriendCapability& data){
LinphoneEnums::FriendCapability LinphoneEnums::fromLinphone(const linphone::Friend::Capability& data){
return static_cast<LinphoneEnums::FriendCapability>(data);
}
@ -98,14 +98,14 @@ LinphoneEnums::CallStatus LinphoneEnums::fromLinphone(const linphone::Call::Stat
return static_cast<LinphoneEnums::CallStatus>(data);
}
linphone::ConferenceLayout LinphoneEnums::toLinphone(const LinphoneEnums::ConferenceLayout& layout){
linphone::Conference::Layout LinphoneEnums::toLinphone(const LinphoneEnums::ConferenceLayout& layout){
if( layout != LinphoneEnums::ConferenceLayoutAudioOnly)
return static_cast<linphone::ConferenceLayout>(layout);
return static_cast<linphone::Conference::Layout>(layout);
else
return linphone::ConferenceLayout::Grid;// Audio Only mode
return linphone::Conference::Layout::Grid;// Audio Only mode
}
LinphoneEnums::ConferenceLayout LinphoneEnums::fromLinphone(const linphone::ConferenceLayout& layout){
LinphoneEnums::ConferenceLayout LinphoneEnums::fromLinphone(const linphone::Conference::Layout& layout){
return static_cast<LinphoneEnums::ConferenceLayout>(layout);
}
@ -125,11 +125,11 @@ LinphoneEnums::ConferenceSchedulerState LinphoneEnums::fromLinphone(const linpho
return static_cast<LinphoneEnums::ConferenceSchedulerState>(state);
}
linphone::ParticipantDeviceState LinphoneEnums::toLinphone(const LinphoneEnums::ParticipantDeviceState& state){
return static_cast<linphone::ParticipantDeviceState>(state);
linphone::ParticipantDevice::State LinphoneEnums::toLinphone(const LinphoneEnums::ParticipantDeviceState& state){
return static_cast<linphone::ParticipantDevice::State>(state);
}
LinphoneEnums::ParticipantDeviceState LinphoneEnums::fromLinphone(const linphone::ParticipantDeviceState& state){
LinphoneEnums::ParticipantDeviceState LinphoneEnums::fromLinphone(const linphone::ParticipantDevice::State& state){
return static_cast<LinphoneEnums::ParticipantDeviceState>(state);
}
@ -140,10 +140,10 @@ LinphoneEnums::TunnelMode LinphoneEnums::fromLinphone(const linphone::Tunnel::Mo
return static_cast<LinphoneEnums::TunnelMode>(data);
}
linphone::RecorderState LinphoneEnums::toLinphone(const LinphoneEnums::RecorderState& data){
return static_cast<linphone::RecorderState>(data);
linphone::Recorder::State LinphoneEnums::toLinphone(const LinphoneEnums::RecorderState& data){
return static_cast<linphone::Recorder::State>(data);
}
LinphoneEnums::RecorderState LinphoneEnums::fromLinphone(const linphone::RecorderState& data){
LinphoneEnums::RecorderState LinphoneEnums::fromLinphone(const linphone::Recorder::State& data){
return static_cast<LinphoneEnums::RecorderState>(data);
}

52
linphone-app/src/utils/LinphoneEnums.hpp
View file

@ -45,15 +45,15 @@ linphone::MediaEncryption toLinphone(const LinphoneEnums::MediaEncryption& encry
LinphoneEnums::MediaEncryption fromLinphone(const linphone::MediaEncryption& encryption);
enum FriendCapability {
FriendCapabilityNone = int(linphone::FriendCapability::None),
FriendCapabilityGroupChat = int(linphone::FriendCapability::GroupChat),
FriendCapabilityLimeX3Dh = int(linphone::FriendCapability::LimeX3Dh),
FriendCapabilityEphemeralMessages = int(linphone::FriendCapability::EphemeralMessages)
FriendCapabilityNone = int(linphone::Friend::Capability::None),
FriendCapabilityGroupChat = int(linphone::Friend::Capability::GroupChat),
FriendCapabilityLimeX3Dh = int(linphone::Friend::Capability::LimeX3Dh),
FriendCapabilityEphemeralMessages = int(linphone::Friend::Capability::EphemeralMessages)
};
Q_ENUM_NS(FriendCapability)
linphone::FriendCapability toLinphone(const LinphoneEnums::FriendCapability& capability);
LinphoneEnums::FriendCapability fromLinphone(const linphone::FriendCapability& capability);
linphone::Friend::Capability toLinphone(const LinphoneEnums::FriendCapability& capability);
LinphoneEnums::FriendCapability fromLinphone(const linphone::Friend::Capability& capability);
enum EventLogType {
@ -130,14 +130,14 @@ linphone::Call::Status toLinphone(const LinphoneEnums::CallStatus& capability);
LinphoneEnums::CallStatus fromLinphone(const linphone::Call::Status& capability);
enum ConferenceLayout {
ConferenceLayoutGrid = int(linphone::ConferenceLayout::Grid),
ConferenceLayoutActiveSpeaker = int(linphone::ConferenceLayout::ActiveSpeaker),
ConferenceLayoutGrid = int(linphone::Conference::Layout::Grid),
ConferenceLayoutActiveSpeaker = int(linphone::Conference::Layout::ActiveSpeaker),
ConferenceLayoutAudioOnly = ConferenceLayoutGrid + ConferenceLayoutActiveSpeaker + 1,
};
Q_ENUM_NS(ConferenceLayout)
linphone::ConferenceLayout toLinphone(const LinphoneEnums::ConferenceLayout& layout);
LinphoneEnums::ConferenceLayout fromLinphone(const linphone::ConferenceLayout& layout);
linphone::Conference::Layout toLinphone(const LinphoneEnums::ConferenceLayout& layout);
LinphoneEnums::ConferenceLayout fromLinphone(const linphone::Conference::Layout& layout);
enum ConferenceInfoState {
@ -164,21 +164,21 @@ LinphoneEnums::ConferenceSchedulerState fromLinphone(const linphone::ConferenceS
enum ParticipantDeviceState {
ParticipantDeviceStateJoining = int(linphone::ParticipantDeviceState::Joining),
ParticipantDeviceStatePresent = int(linphone::ParticipantDeviceState::Present),
ParticipantDeviceStateLeaving = int(linphone::ParticipantDeviceState::Leaving),
ParticipantDeviceStateLeft = int(linphone::ParticipantDeviceState::Left),
ParticipantDeviceStateScheduledForJoining = int(linphone::ParticipantDeviceState::ScheduledForJoining),
ParticipantDeviceStateScheduledForLeaving = int(linphone::ParticipantDeviceState::ScheduledForLeaving),
ParticipantDeviceStateOnHold = int(linphone::ParticipantDeviceState::OnHold),
ParticipantDeviceStateAlerting = int(linphone::ParticipantDeviceState::Alerting),
ParticipantDeviceStateMutedByFocus = int(linphone::ParticipantDeviceState::MutedByFocus),
ParticipantDeviceStateJoining = int(linphone::ParticipantDevice::State::Joining),
ParticipantDeviceStatePresent = int(linphone::ParticipantDevice::State::Present),
ParticipantDeviceStateLeaving = int(linphone::ParticipantDevice::State::Leaving),
ParticipantDeviceStateLeft = int(linphone::ParticipantDevice::State::Left),
ParticipantDeviceStateScheduledForJoining = int(linphone::ParticipantDevice::State::ScheduledForJoining),
ParticipantDeviceStateScheduledForLeaving = int(linphone::ParticipantDevice::State::ScheduledForLeaving),
ParticipantDeviceStateOnHold = int(linphone::ParticipantDevice::State::OnHold),
ParticipantDeviceStateAlerting = int(linphone::ParticipantDevice::State::Alerting),
ParticipantDeviceStateMutedByFocus = int(linphone::ParticipantDevice::State::MutedByFocus),
};
Q_ENUM_NS(ParticipantDeviceState)
linphone::ParticipantDeviceState toLinphone(const LinphoneEnums::ParticipantDeviceState& state);
LinphoneEnums::ParticipantDeviceState fromLinphone(const linphone::ParticipantDeviceState& state);
linphone::ParticipantDevice::State toLinphone(const LinphoneEnums::ParticipantDeviceState& state);
LinphoneEnums::ParticipantDeviceState fromLinphone(const linphone::ParticipantDevice::State& state);
@ -193,14 +193,14 @@ linphone::Tunnel::Mode toLinphone(const LinphoneEnums::TunnelMode& mode);
LinphoneEnums::TunnelMode fromLinphone(const linphone::Tunnel::Mode& mode);
enum RecorderState{
RecorderStateClosed = int(linphone::RecorderState::Closed),
RecorderStatePaused = int(linphone::RecorderState::Paused),
RecorderStateRunning = int(linphone::RecorderState::Running)
RecorderStateClosed = int(linphone::Recorder::State::Closed),
RecorderStatePaused = int(linphone::Recorder::State::Paused),
RecorderStateRunning = int(linphone::Recorder::State::Running)
};
Q_ENUM_NS(RecorderState)
linphone::RecorderState toLinphone(const LinphoneEnums::RecorderState& state);
LinphoneEnums::RecorderState fromLinphone(const linphone::RecorderState& state);
linphone::Recorder::State toLinphone(const LinphoneEnums::RecorderState& state);
LinphoneEnums::RecorderState fromLinphone(const linphone::Recorder::State& state);
enum TransportType{
TransportTypeDtls = int(linphone::TransportType::Dtls),