Adjusts Linphone Qt's code to fit the new API of Liblinphone

src/app/logger/Logger.cpp

@@ -20,7 +20,7 @@
  *      Author: Ronan Abhamon
  */
 
-#include <bctoolbox/logging.h>
+#include <linphone++/linphone.hh>
 #include <linphone/linphonecore.h>
 #include <QDateTime>
 #include <QThread>

src/components/assistant/AssistantModel.cpp

@@ -48,15 +48,15 @@ private:
 
   void onCreateAccount (
     const shared_ptr<linphone::AccountCreator> &,
-    linphone::AccountCreatorStatus status,
+    linphone::AccountCreator::Status status,
     const string &
   ) override {
-    if (status == linphone::AccountCreatorStatusAccountCreated)
+    if (status == linphone::AccountCreator::Status::AccountCreated)
       emit mAssistant->createStatusChanged(QString(""));
     else {
-      if (status == linphone::AccountCreatorStatusRequestFailed)
+      if (status == linphone::AccountCreator::Status::RequestFailed)
         emit mAssistant->createStatusChanged(tr("requestFailed"));
-      else if (status == linphone::AccountCreatorStatusServerError)
+      else if (status == linphone::AccountCreator::Status::ServerError)
         emit mAssistant->createStatusChanged(tr("cannotSendSms"));
       else
         emit mAssistant->createStatusChanged(tr("accountAlreadyExists"));
@@ -65,14 +65,14 @@ private:
 
   void onIsAccountExist (
     const shared_ptr<linphone::AccountCreator> &creator,
-    linphone::AccountCreatorStatus status,
+    linphone::AccountCreator::Status status,
     const string &
   ) override {
-    if (status == linphone::AccountCreatorStatusAccountExist || status == linphone::AccountCreatorStatusAccountExistWithAlias) {
+    if (status == linphone::AccountCreator::Status::AccountExist || status == linphone::AccountCreator::Status::AccountExistWithAlias) {
       createProxyConfig(creator);
       emit mAssistant->loginStatusChanged(QString(""));
     } else {
-      if (status == linphone::AccountCreatorStatusRequestFailed)
+      if (status == linphone::AccountCreator::Status::RequestFailed)
         emit mAssistant->loginStatusChanged(tr("requestFailed"));
       else
         emit mAssistant->loginStatusChanged(tr("loginWithUsernameFailed"));
@@ -81,19 +81,19 @@ private:
 
   void onActivateAccount (
     const shared_ptr<linphone::AccountCreator> &creator,
-    linphone::AccountCreatorStatus status,
+    linphone::AccountCreator::Status status,
     const string &
   ) override {
     if (
-      status == linphone::AccountCreatorStatusAccountActivated ||
-      status == linphone::AccountCreatorStatusAccountAlreadyActivated
+      status == linphone::AccountCreator::Status::AccountActivated ||
+      status == linphone::AccountCreator::Status::AccountAlreadyActivated
     ) {
       if (creator->getEmail().empty())
         createProxyConfig(creator);
 
       emit mAssistant->activateStatusChanged(QString(""));
     } else {
-      if (status == linphone::AccountCreatorStatusRequestFailed)
+      if (status == linphone::AccountCreator::Status::RequestFailed)
         emit mAssistant->activateStatusChanged(tr("requestFailed"));
       else
         emit mAssistant->activateStatusChanged(tr("smsActivationFailed"));
@@ -102,14 +102,14 @@ private:
 
   void onIsAccountActivated (
     const shared_ptr<linphone::AccountCreator> &creator,
-    linphone::AccountCreatorStatus status,
+    linphone::AccountCreator::Status status,
     const string &
   ) override {
-    if (status == linphone::AccountCreatorStatusAccountActivated) {
+    if (status == linphone::AccountCreator::Status::AccountActivated) {
       createProxyConfig(creator);
       emit mAssistant->activateStatusChanged(QString(""));
     } else {
-      if (status == linphone::AccountCreatorStatusRequestFailed)
+      if (status == linphone::AccountCreator::Status::RequestFailed)
         emit mAssistant->activateStatusChanged(tr("requestFailed"));
       else
         emit mAssistant->activateStatusChanged(tr("emailActivationFailed"));
@@ -118,15 +118,15 @@ private:
 
   void onRecoverAccount (
     const shared_ptr<linphone::AccountCreator> &,
-    linphone::AccountCreatorStatus status,
+    linphone::AccountCreator::Status status,
     const string &
   ) override {
-    if (status == linphone::AccountCreatorStatusRequestOk) {
+    if (status == linphone::AccountCreator::Status::RequestOk) {
       emit mAssistant->recoverStatusChanged(QString(""));
     } else {
-      if (status == linphone::AccountCreatorStatusRequestFailed)
+      if (status == linphone::AccountCreator::Status::RequestFailed)
         emit mAssistant->recoverStatusChanged(tr("requestFailed"));
-      else if (status == linphone::AccountCreatorStatusServerError)
+      else if (status == linphone::AccountCreator::Status::ServerError)
         emit mAssistant->recoverStatusChanged(tr("cannotSendSms"));
       else
         emit mAssistant->recoverStatusChanged(tr("loginWithPhoneNumberFailed"));
@@ -243,12 +243,12 @@ void AssistantModel::setEmail (const QString &email) {
   QString error;
 
   switch (mAccountCreator->setEmail(::Utils::appStringToCoreString(email))) {
-    case linphone::AccountCreatorEmailStatusOk:
+    case linphone::AccountCreator::EmailStatus::Ok:
       break;
-    case linphone::AccountCreatorEmailStatusMalformed:
+    case linphone::AccountCreator::EmailStatus::Malformed:
       error = tr("emailStatusMalformed");
       break;
-    case linphone::AccountCreatorEmailStatusInvalidCharacters:
+    case linphone::AccountCreator::EmailStatus::InvalidCharacters:
       error = tr("emailStatusMalformedInvalidCharacters");
       break;
   }
@@ -267,19 +267,19 @@ void AssistantModel::setPassword (const QString &password) {
   QString error;
 
   switch (mAccountCreator->setPassword(::Utils::appStringToCoreString(password))) {
-    case linphone::AccountCreatorPasswordStatusOk:
+    case linphone::AccountCreator::PasswordStatus::Ok:
       break;
-    case linphone::AccountCreatorPasswordStatusTooShort:
+    case linphone::AccountCreator::PasswordStatus::TooShort:
       error = tr("passwordStatusTooShort").arg(config->getInt("assistant", "password_min_length", 1));
       break;
-    case linphone::AccountCreatorPasswordStatusTooLong:
+    case linphone::AccountCreator::PasswordStatus::TooLong:
       error = tr("passwordStatusTooLong").arg(config->getInt("assistant", "password_max_length", -1));
       break;
-    case linphone::AccountCreatorPasswordStatusInvalidCharacters:
+    case linphone::AccountCreator::PasswordStatus::InvalidCharacters:
       error = tr("passwordStatusInvalidCharacters")
         .arg(::Utils::coreStringToAppString(config->getString("assistant", "password_regex", "")));
       break;
-    case linphone::AccountCreatorPasswordStatusMissingCharacters:
+    case linphone::AccountCreator::PasswordStatus::MissingCharacters:
       error = tr("passwordStatusMissingCharacters")
         .arg(::Utils::coreStringToAppString(config->getString("assistant", "missing_characters", "")));
       break;
@@ -310,18 +310,18 @@ void AssistantModel::setPhoneNumber (const QString &phoneNumber) {
   QString error;
 
   switch (mAccountCreator->setPhoneNumber(::Utils::appStringToCoreString(phoneNumber), ::Utils::appStringToCoreString(mCountryCode))) {
-    case linphone::AccountCreatorPhoneNumberStatusOk:
+    case int(linphone::AccountCreator::PhoneNumberStatus::Ok):
       break;
-    case linphone::AccountCreatorPhoneNumberStatusInvalid:
+    case int(linphone::AccountCreator::PhoneNumberStatus::Invalid):
       error = tr("phoneNumberStatusInvalid");
       break;
-    case linphone::AccountCreatorPhoneNumberStatusTooShort:
+    case int(linphone::AccountCreator::PhoneNumberStatus::TooShort):
       error = tr("phoneNumberStatusTooShort");
       break;
-    case linphone::AccountCreatorPhoneNumberStatusTooLong:
+    case int(linphone::AccountCreator::PhoneNumberStatus::TooLong):
       error = tr("phoneNumberStatusTooLong");
       break;
-    case linphone::AccountCreatorPhoneNumberStatusInvalidCountryCode:
+    case int(linphone::AccountCreator::PhoneNumberStatus::InvalidCountryCode):
       error = tr("phoneNumberStatusInvalidCountryCode");
       break;
     default:
@@ -393,24 +393,24 @@ void AssistantModel::setConfigFilename (const QString &configFilename) {
 
 // -----------------------------------------------------------------------------
 
-QString AssistantModel::mapAccountCreatorUsernameStatusToString (linphone::AccountCreatorUsernameStatus status) const {
+QString AssistantModel::mapAccountCreatorUsernameStatusToString (linphone::AccountCreator::UsernameStatus status) const {
   shared_ptr<linphone::Config> config = CoreManager::getInstance()->getCore()->getConfig();
   QString error;
 
   switch (status) {
-    case linphone::AccountCreatorUsernameStatusOk:
+    case linphone::AccountCreator::UsernameStatus::Ok:
       break;
-    case linphone::AccountCreatorUsernameStatusTooShort:
+    case linphone::AccountCreator::UsernameStatus::TooShort:
       error = tr("usernameStatusTooShort").arg(config->getInt("assistant", "username_min_length", 1));
       break;
-    case linphone::AccountCreatorUsernameStatusTooLong:
+    case linphone::AccountCreator::UsernameStatus::TooLong:
       error = tr("usernameStatusTooLong").arg(config->getInt("assistant", "username_max_length", -1));
       break;
-    case linphone::AccountCreatorUsernameStatusInvalidCharacters:
+    case linphone::AccountCreator::UsernameStatus::InvalidCharacters:
       error = tr("usernameStatusInvalidCharacters")
         .arg(::Utils::coreStringToAppString(config->getString("assistant", "username_regex", "")));
       break;
-    case linphone::AccountCreatorUsernameStatusInvalid:
+    case linphone::AccountCreator::UsernameStatus::Invalid:
       error = tr("usernameStatusInvalid");
       break;
   }

src/components/assistant/AssistantModel.hpp

@@ -94,7 +94,7 @@ private:
   QString getConfigFilename () const;
   void setConfigFilename (const QString &configFilename);
 
-  QString mapAccountCreatorUsernameStatusToString (linphone::AccountCreatorUsernameStatus status) const;
+  QString mapAccountCreatorUsernameStatusToString (linphone::AccountCreator::UsernameStatus status) const;
 
   QString mCountryCode;
   QString mConfigFilename;

src/components/call/CallModel.cpp

@@ -88,14 +88,14 @@ void CallModel::setRecordFile (shared_ptr<linphone::CallParams> &callParams) {
 
 void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callStats) {
   switch (callStats->getType()) {
-    case linphone::StreamTypeText:
-    case linphone::StreamTypeUnknown:
+    case linphone::StreamType::Text:
+    case linphone::StreamType::Unknown:
       break;
 
-    case linphone::StreamTypeAudio:
+    case linphone::StreamType::Audio:
       updateStats(callStats, mAudioStats);
       break;
-    case linphone::StreamTypeVideo:
+    case linphone::StreamType::Video:
       updateStats(callStats, mVideoStats);
       break;
   }
@@ -243,42 +243,42 @@ void CallModel::stopRecording () {
 
 // -----------------------------------------------------------------------------
 
-void CallModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::CallState state) {
+void CallModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::Call::State state) {
   if (call != mCall)
     return;
 
   updateIsInConference();
 
   switch (state) {
-    case linphone::CallStateError:
-    case linphone::CallStateEnd:
+    case linphone::Call::State::Error:
+    case linphone::Call::State::End:
       setCallErrorFromReason(call->getReason());
       stopAutoAnswerTimer();
       mPausedByRemote = false;
       break;
 
-    case linphone::CallStateConnected:
-    case linphone::CallStateReferred:
-    case linphone::CallStateReleased:
-    case linphone::CallStateStreamsRunning:
+    case linphone::Call::State::Connected:
+    case linphone::Call::State::Referred:
+    case linphone::Call::State::Released:
+    case linphone::Call::State::StreamsRunning:
       mPausedByRemote = false;
       break;
 
-    case linphone::CallStatePausedByRemote:
+    case linphone::Call::State::PausedByRemote:
       mNotifyCameraFirstFrameReceived = true;
       mPausedByRemote = true;
       break;
 
-    case linphone::CallStatePausing:
+    case linphone::Call::State::Pausing:
       mNotifyCameraFirstFrameReceived = true;
       mPausedByUser = true;
       break;
 
-    case linphone::CallStateResuming:
+    case linphone::Call::State::Resuming:
       mPausedByUser = false;
       break;
 
-    case linphone::CallStateUpdatedByRemote:
+    case linphone::Call::State::UpdatedByRemote:
       if (!mCall->getCurrentParams()->videoEnabled() && mCall->getRemoteParams()->videoEnabled()) {
         mCall->deferUpdate();
         emit videoRequested();
@@ -286,17 +286,17 @@ void CallModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call,
 
       break;
 
-    case linphone::CallStateIdle:
-    case linphone::CallStateIncomingReceived:
-    case linphone::CallStateOutgoingInit:
-    case linphone::CallStateOutgoingProgress:
-    case linphone::CallStateOutgoingRinging:
-    case linphone::CallStateOutgoingEarlyMedia:
-    case linphone::CallStatePaused:
-    case linphone::CallStateIncomingEarlyMedia:
-    case linphone::CallStateUpdating:
-    case linphone::CallStateEarlyUpdatedByRemote:
-    case linphone::CallStateEarlyUpdating:
+    case linphone::Call::State::Idle:
+    case linphone::Call::State::IncomingReceived:
+    case linphone::Call::State::OutgoingInit:
+    case linphone::Call::State::OutgoingProgress:
+    case linphone::Call::State::OutgoingRinging:
+    case linphone::Call::State::OutgoingEarlyMedia:
+    case linphone::Call::State::Paused:
+    case linphone::Call::State::IncomingEarlyMedia:
+    case linphone::Call::State::Updating:
+    case linphone::Call::State::EarlyUpdatedByRemote:
+    case linphone::Call::State::EarlyUpdating:
       break;
   }
 
@@ -327,39 +327,39 @@ void CallModel::stopAutoAnswerTimer () const {
 
 CallModel::CallStatus CallModel::getStatus () const {
   switch (mCall->getState()) {
-    case linphone::CallStateConnected:
-    case linphone::CallStateStreamsRunning:
+    case linphone::Call::State::Connected:
+    case linphone::Call::State::StreamsRunning:
       return CallStatusConnected;
 
-    case linphone::CallStateEnd:
-    case linphone::CallStateError:
-    case linphone::CallStateReferred:
-    case linphone::CallStateReleased:
+    case linphone::Call::State::End:
+    case linphone::Call::State::Error:
+    case linphone::Call::State::Referred:
+    case linphone::Call::State::Released:
       return CallStatusEnded;
 
-    case linphone::CallStatePaused:
-    case linphone::CallStatePausedByRemote:
-    case linphone::CallStatePausing:
-    case linphone::CallStateResuming:
+    case linphone::Call::State::Paused:
+    case linphone::Call::State::PausedByRemote:
+    case linphone::Call::State::Pausing:
+    case linphone::Call::State::Resuming:
       return CallStatusPaused;
 
-    case linphone::CallStateUpdating:
-    case linphone::CallStateUpdatedByRemote:
+    case linphone::Call::State::Updating:
+    case linphone::Call::State::UpdatedByRemote:
       return mPausedByRemote ? CallStatusPaused : CallStatusConnected;
 
-    case linphone::CallStateEarlyUpdatedByRemote:
-    case linphone::CallStateEarlyUpdating:
-    case linphone::CallStateIdle:
-    case linphone::CallStateIncomingEarlyMedia:
-    case linphone::CallStateIncomingReceived:
-    case linphone::CallStateOutgoingEarlyMedia:
-    case linphone::CallStateOutgoingInit:
-    case linphone::CallStateOutgoingProgress:
-    case linphone::CallStateOutgoingRinging:
+    case linphone::Call::State::EarlyUpdatedByRemote:
+    case linphone::Call::State::EarlyUpdating:
+    case linphone::Call::State::Idle:
+    case linphone::Call::State::IncomingEarlyMedia:
+    case linphone::Call::State::IncomingReceived:
+    case linphone::Call::State::OutgoingEarlyMedia:
+    case linphone::Call::State::OutgoingInit:
+    case linphone::Call::State::OutgoingProgress:
+    case linphone::Call::State::OutgoingRinging:
       break;
   }
 
-  return mCall->getDir() == linphone::CallDirIncoming ? CallStatusIncoming : CallStatusOutgoing;
+  return mCall->getDir() == linphone::Call::Dir::Incoming ? CallStatusIncoming : CallStatusOutgoing;
 }
 
 // -----------------------------------------------------------------------------
@@ -385,16 +385,16 @@ QString CallModel::getCallError () const {
 
 void CallModel::setCallErrorFromReason (linphone::Reason reason) {
   switch (reason) {
-    case linphone::ReasonDeclined:
+    case linphone::Reason::Declined:
       mCallError = tr("callErrorDeclined");
       break;
-    case linphone::ReasonNotFound:
+    case linphone::Reason::NotFound:
       mCallError = tr("callErrorNotFound");
       break;
-    case linphone::ReasonBusy:
+    case linphone::Reason::Busy:
       mCallError = tr("callErrorBusy");
       break;
-    case linphone::ReasonNotAcceptable:
+    case linphone::Reason::NotAcceptable:
       mCallError = tr("callErrorNotAcceptable");
       break;
     default:
@@ -462,10 +462,10 @@ bool CallModel::getPausedByUser () const {
 
 void CallModel::setPausedByUser (bool status) {
   switch (mCall->getState()) {
-    case linphone::CallStateConnected:
-    case linphone::CallStateStreamsRunning:
-    case linphone::CallStatePaused:
-    case linphone::CallStatePausedByRemote:
+    case linphone::Call::State::Connected:
+    case linphone::Call::State::StreamsRunning:
+    case linphone::Call::State::Paused:
+    case linphone::Call::State::PausedByRemote:
       break;
     default: return;
   }
@@ -496,8 +496,8 @@ void CallModel::setVideoEnabled (bool status) {
   }
 
   switch (mCall->getState()) {
-    case linphone::CallStateConnected:
-    case linphone::CallStateStreamsRunning:
+    case linphone::Call::State::Connected:
+    case linphone::Call::State::StreamsRunning:
       break;
     default: return;
   }
@@ -515,10 +515,10 @@ void CallModel::setVideoEnabled (bool status) {
 
 bool CallModel::getUpdating () const {
   switch (mCall->getState()) {
-    case linphone::CallStateConnected:
-    case linphone::CallStateStreamsRunning:
-    case linphone::CallStatePaused:
-    case linphone::CallStatePausedByRemote:
+    case linphone::Call::State::Connected:
+    case linphone::Call::State::StreamsRunning:
+    case linphone::Call::State::Paused:
+    case linphone::Call::State::PausedByRemote:
       return false;
 
     default:
@@ -556,33 +556,33 @@ bool CallModel::isSecured () const {
   shared_ptr<const linphone::CallParams> params = mCall->getCurrentParams();
   linphone::MediaEncryption encryption = params->getMediaEncryption();
   return (
-    encryption == linphone::MediaEncryptionZRTP && mCall->getAuthenticationTokenVerified()
-  ) || encryption == linphone::MediaEncryptionSRTP || encryption == linphone::MediaEncryptionDTLS;
+    encryption == linphone::MediaEncryption::ZRTP && mCall->getAuthenticationTokenVerified()
+  ) || encryption == linphone::MediaEncryption::SRTP || encryption == linphone::MediaEncryption::DTLS;
 }
 
 // -----------------------------------------------------------------------------
 
 QString CallModel::getLocalSas () const {
   QString token = ::Utils::coreStringToAppString(mCall->getAuthenticationToken());
-  return mCall->getDir() == linphone::CallDirIncoming ? token.left(2).toUpper() : token.right(2).toUpper();
+  return mCall->getDir() == linphone::Call::Dir::Incoming ? token.left(2).toUpper() : token.right(2).toUpper();
 }
 
 QString CallModel::getRemoteSas () const {
   QString token = ::Utils::coreStringToAppString(mCall->getAuthenticationToken());
-  return mCall->getDir() != linphone::CallDirIncoming ? token.left(2).toUpper() : token.right(2).toUpper();
+  return mCall->getDir() != linphone::Call::Dir::Incoming ? token.left(2).toUpper() : token.right(2).toUpper();
 }
 
 // -----------------------------------------------------------------------------
 
 QString CallModel::getSecuredString () const {
   switch (mCall->getCurrentParams()->getMediaEncryption()) {
-    case linphone::MediaEncryptionSRTP:
+    case linphone::MediaEncryption::SRTP:
       return QStringLiteral("SRTP");
-    case linphone::MediaEncryptionZRTP:
+    case linphone::MediaEncryption::ZRTP:
       return QStringLiteral("ZRTP");
-    case linphone::MediaEncryptionDTLS:
+    case linphone::MediaEncryption::DTLS:
       return QStringLiteral("DTLS");
-    case linphone::MediaEncryptionNone:
+    case linphone::MediaEncryption::None:
       break;
   }
 
@@ -613,10 +613,10 @@ void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callSt
   shared_ptr<const linphone::PayloadType> payloadType;
 
   switch (callStats->getType()) {
-    case linphone::StreamTypeAudio:
+    case linphone::StreamType::Audio:
       payloadType = params->getUsedAudioPayloadType();
       break;
-    case linphone::StreamTypeVideo:
+    case linphone::StreamType::Video:
       payloadType = params->getUsedVideoPayloadType();
       break;
     default:
@@ -625,10 +625,10 @@ void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callSt
 
   QString family;
   switch (callStats->getIpFamilyOfRemote()) {
-    case linphone::AddressFamilyInet:
+    case linphone::AddressFamily::Inet:
       family = QStringLiteral("IPv4");
       break;
-    case linphone::AddressFamilyInet6:
+    case linphone::AddressFamily::Inet6:
       family = QStringLiteral("IPv6");
       break;
     default:
@@ -649,10 +649,10 @@ void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callSt
   statsList << ::createStat(tr("callStatsReceiverLossRate"), QStringLiteral("%1 %").arg(callStats->getReceiverLossRate()));
 
   switch (callStats->getType()) {
-    case linphone::StreamTypeAudio:
+    case linphone::StreamType::Audio:
       statsList << ::createStat(tr("callStatsJitterBuffer"), QStringLiteral("%1 ms").arg(callStats->getJitterBufferSizeMs()));
       break;
-    case linphone::StreamTypeVideo: {
+    case linphone::StreamType::Video: {
       const QString sentVideoDefinitionName = ::Utils::coreStringToAppString(params->getSentVideoDefinition()->getName());
       const QString sentVideoDefinition = QStringLiteral("%1x%2")
         .arg(params->getSentVideoDefinition()->getWidth())
@@ -684,17 +684,17 @@ void CallModel::updateStats (const shared_ptr<const linphone::CallStats> &callSt
 
 QString CallModel::iceStateToString (linphone::IceState state) const {
   switch (state) {
-    case linphone::IceStateNotActivated:
+    case linphone::IceState::NotActivated:
       return tr("iceStateNotActivated");
-    case linphone::IceStateFailed:
+    case linphone::IceState::Failed:
       return tr("iceStateFailed");
-    case linphone::IceStateInProgress:
+    case linphone::IceState::InProgress:
       return tr("iceStateInProgress");
-    case linphone::IceStateReflexiveConnection:
+    case linphone::IceState::ReflexiveConnection:
       return tr("iceStateReflexiveConnection");
-    case linphone::IceStateHostConnection:
+    case linphone::IceState::HostConnection:
       return tr("iceStateHostConnection");
-    case linphone::IceStateRelayConnection:
+    case linphone::IceState::RelayConnection:
       return tr("iceStateRelayConnection");
   }
 

src/components/call/CallModel.hpp

@@ -78,10 +78,10 @@ public:
   Q_ENUM(CallStatus);
 
   enum CallEncryption {
-    CallEncryptionNone = linphone::MediaEncryptionNone,
-    CallEncryptionDtls = linphone::MediaEncryptionDTLS,
-    CallEncryptionSrtp = linphone::MediaEncryptionSRTP,
-    CallEncryptionZrtp = linphone::MediaEncryptionZRTP
+    CallEncryptionNone = int(linphone::MediaEncryption::None),
+    CallEncryptionDtls = int(linphone::MediaEncryption::DTLS),
+    CallEncryptionSrtp = int(linphone::MediaEncryption::SRTP),
+    CallEncryptionZrtp = int(linphone::MediaEncryption::ZRTP)
   };
 
   Q_ENUM(CallEncryption);
@@ -139,14 +139,14 @@ signals:
   void cameraFirstFrameReceived (unsigned int width, unsigned int height);
 
 private:
-  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::CallState state);
+  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::Call::State state);
 
   void stopAutoAnswerTimer () const;
 
   CallStatus getStatus () const;
 
   bool isOutgoing () const {
-    return mCall->getDir() == linphone::CallDirOutgoing;
+    return mCall->getDir() == linphone::Call::Dir::Outgoing;
   }
 
   void updateIsInConference ();

src/components/calls/CallsListModel.cpp

@@ -172,23 +172,23 @@ static void joinConference (const shared_ptr<linphone::Call> &call) {
   addModel->update();
 }
 
-void CallsListModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::CallState state) {
+void CallsListModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::Call::State state) {
   switch (state) {
-    case linphone::CallStateIncomingReceived:
+    case linphone::Call::State::IncomingReceived:
       addCall(call);
       ::joinConference(call);
       break;
 
-    case linphone::CallStateOutgoingInit:
+    case linphone::Call::State::OutgoingInit:
       addCall(call);
       break;
 
-    case linphone::CallStateEnd:
-    case linphone::CallStateError:
+    case linphone::Call::State::End:
+    case linphone::Call::State::Error:
       removeCall(call);
       break;
 
-    case linphone::CallStateStreamsRunning: {
+    case linphone::Call::State::StreamsRunning: {
       int index = ::findCallIndex(mList, call);
       emit callRunning(index, &call->getData<CallModel>("call-model"));
     } break;
@@ -221,7 +221,7 @@ bool CallsListModel::removeRows (int row, int count, const QModelIndex &parent)
 // -----------------------------------------------------------------------------
 
 void CallsListModel::addCall (const shared_ptr<linphone::Call> &call) {
-  if (call->getDir() == linphone::CallDirOutgoing)
+  if (call->getDir() == linphone::Call::Dir::Outgoing)
     App::smartShowWindow(App::getInstance()->getCallsWindow());
 
   CallModel *callModel = new CallModel(call);

src/components/calls/CallsListModel.hpp

@@ -60,7 +60,7 @@ private:
   bool removeRow (int row, const QModelIndex &parent = QModelIndex());
   bool removeRows (int row, int count, const QModelIndex &parent = QModelIndex()) override;
 
-  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::CallState state);
+  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::Call::State state);
 
   void addCall (const std::shared_ptr<linphone::Call> &call);
   void removeCall (const std::shared_ptr<linphone::Call> &call);

src/components/chat/ChatModel.cpp

@@ -180,7 +180,7 @@ private:
     signalDataChanged(it);
   }
 
-  void onMsgStateChanged (const shared_ptr<linphone::ChatMessage> &message, linphone::ChatMessageState state) override {
+  void onMsgStateChanged (const shared_ptr<linphone::ChatMessage> &message, linphone::ChatMessage::State state) override {
     if (!mChatModel)
       return;
 
@@ -189,7 +189,7 @@ private:
       return;
 
     // File message downloaded.
-    if (state == linphone::ChatMessageStateFileTransferDone && !message->isOutgoing()) {
+    if (state == linphone::ChatMessage::State::FileTransferDone && !message->isOutgoing()) {
       ::createThumbnail(message);
       ::fillThumbnailProperty((*it).first, message);
 
@@ -201,7 +201,7 @@ private:
       App::getInstance()->getNotifier()->notifyReceivedFileMessage(message);
     }
 
-    (*it).first["status"] = state;
+    (*it).first["status"] = int(state);
 
     signalDataChanged(it);
   }
@@ -305,8 +305,8 @@ void ChatModel::setSipAddress (const QString &sipAddress) {
 
     // Old workaround.
     // It can exist messages with a not delivered status. It's a linphone core bug.
-    if (message->getState() == linphone::ChatMessageStateInProgress)
-      map["status"] = linphone::ChatMessageStateNotDelivered;
+    if (message->getState() == linphone::ChatMessage::State::InProgress)
+      map["status"] = int(linphone::ChatMessage::State::NotDelivered);
 
     mEntries << qMakePair(map, static_pointer_cast<void>(message));
   }
@@ -435,7 +435,7 @@ void ChatModel::downloadFile (int id) {
 
   shared_ptr<linphone::ChatMessage> message = static_pointer_cast<linphone::ChatMessage>(entry.second);
 
-  switch (message->getState()) {
+  switch (int(message->getState())) {
     case MessageStatusDelivered:
     case MessageStatusDeliveredToUser:
     case MessageStatusDisplayed:
@@ -529,8 +529,8 @@ void ChatModel::fillMessageEntry (QVariantMap &dest, const shared_ptr<linphone::
   dest["type"] = EntryType::MessageEntry;
   dest["timestamp"] = QDateTime::fromMSecsSinceEpoch(message->getTime() * 1000);
   dest["content"] = ::Utils::coreStringToAppString(message->getText());
-  dest["isOutgoing"] = message->isOutgoing() || message->getState() == linphone::ChatMessageStateIdle;
-  dest["status"] = message->getState();
+  dest["isOutgoing"] = message->isOutgoing() || message->getState() == linphone::ChatMessage::State::Idle;
+  dest["status"] = int(message->getState());
 
   shared_ptr<const linphone::Content> content = message->getFileTransferInformation();
   if (content) {
@@ -547,8 +547,8 @@ void ChatModel::fillCallStartEntry (QVariantMap &dest, const shared_ptr<linphone
 
   dest["type"] = EntryType::CallEntry;
   dest["timestamp"] = timestamp;
-  dest["isOutgoing"] = callLog->getDir() == linphone::CallDirOutgoing;
-  dest["status"] = callLog->getStatus();
+  dest["isOutgoing"] = callLog->getDir() == linphone::Call::Dir::Outgoing;
+  dest["status"] = int(callLog->getStatus());
   dest["isStart"] = true;
 }
 
@@ -557,8 +557,8 @@ void ChatModel::fillCallEndEntry (QVariantMap &dest, const shared_ptr<linphone::
 
   dest["type"] = EntryType::CallEntry;
   dest["timestamp"] = timestamp;
-  dest["isOutgoing"] = callLog->getDir() == linphone::CallDirOutgoing;
-  dest["status"] = callLog->getStatus();
+  dest["isOutgoing"] = callLog->getDir() == linphone::Call::Dir::Outgoing;
+  dest["status"] = int(callLog->getStatus());
   dest["isStart"] = false;
 }
 
@@ -576,7 +576,7 @@ void ChatModel::removeEntry (ChatEntryData &pair) {
     }
 
     case ChatModel::CallEntry: {
-      if (pair.first["status"].toInt() == linphone::CallStatusSuccess) {
+      if (pair.first["status"].toInt() == int(linphone::Call::Status::Success)) {
         // WARNING: Unable to remove symmetric call here. (start/end)
         // We are between `beginRemoveRows` and `endRemoveRows`.
         // A solution is to schedule a `removeEntry` call in the Qt main loop.
@@ -601,16 +601,16 @@ void ChatModel::removeEntry (ChatEntryData &pair) {
 }
 
 void ChatModel::insertCall (const shared_ptr<linphone::CallLog> &callLog) {
-  linphone::CallStatus status = callLog->getStatus();
+  linphone::Call::Status status = callLog->getStatus();
 
   switch (status) {
-    case linphone::CallStatusAborted:
-    case linphone::CallStatusEarlyAborted:
+    case linphone::Call::Status::Aborted:
+    case linphone::Call::Status::EarlyAborted:
       return; // Ignore aborted calls.
 
-    case linphone::CallStatusSuccess:
-    case linphone::CallStatusMissed:
-    case linphone::CallStatusDeclined:
+    case linphone::Call::Status::Success:
+    case linphone::Call::Status::Missed:
+    case linphone::Call::Status::Declined:
       break;
   }
 
@@ -637,7 +637,7 @@ void ChatModel::insertCall (const shared_ptr<linphone::CallLog> &callLog) {
   auto it = insertEntry(qMakePair(start, static_pointer_cast<void>(callLog)));
 
   // Add end call. (if necessary)
-  if (status == linphone::CallStatusSuccess) {
+  if (status == linphone::Call::Status::Success) {
     QVariantMap end;
     fillCallEndEntry(end, callLog);
     insertEntry(qMakePair(end, static_pointer_cast<void>(callLog)), &it);
@@ -658,9 +658,9 @@ void ChatModel::insertMessageAtEnd (const shared_ptr<linphone::ChatMessage> &mes
 
 // -----------------------------------------------------------------------------
 
-void ChatModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::CallState state) {
+void ChatModel::handleCallStateChanged (const shared_ptr<linphone::Call> &call, linphone::Call::State state) {
   if (
-    (state == linphone::CallStateEnd || state == linphone::CallStateError) &&
+    (state == linphone::Call::State::End || state == linphone::Call::State::Error) &&
     mChatRoom == CoreManager::getInstance()->getCore()->getChatRoom(call->getRemoteAddress())
   )
     insertCall(call->getCallLog());

src/components/chat/ChatModel.hpp

@@ -52,22 +52,22 @@ public:
   Q_ENUM(EntryType);
 
   enum CallStatus {
-    CallStatusDeclined = linphone::CallStatusDeclined,
-    CallStatusMissed = linphone::CallStatusMissed,
-    CallStatusSuccess = linphone::CallStatusSuccess
+    CallStatusDeclined = int(linphone::Call::Status::Declined),
+    CallStatusMissed = int(linphone::Call::Status::Missed),
+    CallStatusSuccess = int(linphone::Call::Status::Success)
   };
 
   Q_ENUM(CallStatus);
 
   enum MessageStatus {
-    MessageStatusDelivered = linphone::ChatMessageStateDelivered,
-    MessageStatusDeliveredToUser = linphone::ChatMessageStateDeliveredToUser,
-    MessageStatusDisplayed = linphone::ChatMessageStateDisplayed,
-    MessageStatusFileTransferDone = linphone::ChatMessageStateFileTransferDone,
-    MessageStatusFileTransferError = linphone::ChatMessageStateFileTransferError,
-    MessageStatusIdle = linphone::ChatMessageStateIdle,
-    MessageStatusInProgress = linphone::ChatMessageStateInProgress,
-    MessageStatusNotDelivered = linphone::ChatMessageStateNotDelivered
+    MessageStatusDelivered = int(linphone::ChatMessage::State::Delivered),
+    MessageStatusDeliveredToUser = int(linphone::ChatMessage::State::DeliveredToUser),
+    MessageStatusDisplayed = int(linphone::ChatMessage::State::Displayed),
+    MessageStatusFileTransferDone = int(linphone::ChatMessage::State::FileTransferDone),
+    MessageStatusFileTransferError = int(linphone::ChatMessage::State::FileTransferError),
+    MessageStatusIdle = int(linphone::ChatMessage::State::Idle),
+    MessageStatusInProgress = int(linphone::ChatMessage::State::InProgress),
+    MessageStatusNotDelivered = int(linphone::ChatMessage::State::NotDelivered)
   };
 
   Q_ENUM(MessageStatus);
@@ -134,7 +134,7 @@ private:
   void insertCall (const std::shared_ptr<linphone::CallLog> &callLog);
   void insertMessageAtEnd (const std::shared_ptr<linphone::ChatMessage> &message);
 
-  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::CallState state);
+  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::Call::State state);
   void handleIsComposingChanged (const std::shared_ptr<linphone::ChatRoom> &chatRoom);
   void handleMessageReceived (const std::shared_ptr<linphone::ChatMessage> &message);
 

src/components/contacts/ContactsListModel.cpp

@@ -140,7 +140,7 @@ ContactModel *ContactsListModel::addContact (VcardModel *vcardModel) {
 
   if (
     mLinphoneFriends->addFriend(contact->mLinphoneFriend) !=
-    linphone::FriendListStatus::FriendListStatusOK
+    linphone::FriendList::Status::OK
   ) {
     qWarning() << QStringLiteral("Unable to add contact from vcard:") << vcardModel;
     delete contact;

src/components/core/CoreHandlers.cpp

@@ -88,12 +88,12 @@ void CoreHandlers::onAuthenticationRequested (
 void CoreHandlers::onCallStateChanged (
   const shared_ptr<linphone::Core> &,
   const shared_ptr<linphone::Call> &call,
-  linphone::CallState state,
+  linphone::Call::State state,
   const string &
 ) {
   emit callStateChanged(call, state);
 
-  if (call->getState() == linphone::CallStateIncomingReceived)
+  if (call->getState() == linphone::Call::State::IncomingReceived)
     App::getInstance()->getNotifier()->notifyReceivedCall(call);
 }
 
@@ -110,7 +110,7 @@ void CoreHandlers::onGlobalStateChanged (
   linphone::GlobalState gstate,
   const string &
 ) {
-  if (gstate == linphone::GlobalStateOn) {
+  if (gstate == linphone::GlobalState::On) {
     mCoreStartedLock->lock();
 
     Q_ASSERT(mCoreStarted == false);
@@ -130,7 +130,7 @@ void CoreHandlers::onIsComposingReceived (
 
 void CoreHandlers::onLogCollectionUploadStateChanged (
   const shared_ptr<linphone::Core> &,
-  linphone::CoreLogCollectionUploadState state,
+  linphone::Core::LogCollectionUploadState state,
   const string &info
 ) {
   emit logsUploadStateChanged(state, info);
@@ -190,46 +190,46 @@ void CoreHandlers::onRegistrationStateChanged (
 void CoreHandlers::onTransferStateChanged (
   const shared_ptr<linphone::Core> &,
   const shared_ptr<linphone::Call> &call,
-  linphone::CallState state
+  linphone::Call::State state
 ) {
   switch (state) {
-    case linphone::CallStateEarlyUpdatedByRemote:
-    case linphone::CallStateEarlyUpdating:
-    case linphone::CallStateIdle:
-    case linphone::CallStateIncomingEarlyMedia:
-    case linphone::CallStateIncomingReceived:
-    case linphone::CallStateOutgoingEarlyMedia:
-    case linphone::CallStateOutgoingRinging:
-    case linphone::CallStatePaused:
-    case linphone::CallStatePausedByRemote:
-    case linphone::CallStatePausing:
-    case linphone::CallStateReferred:
-    case linphone::CallStateReleased:
-    case linphone::CallStateResuming:
-    case linphone::CallStateStreamsRunning:
-    case linphone::CallStateUpdatedByRemote:
-    case linphone::CallStateUpdating:
+    case linphone::Call::State::EarlyUpdatedByRemote:
+    case linphone::Call::State::EarlyUpdating:
+    case linphone::Call::State::Idle:
+    case linphone::Call::State::IncomingEarlyMedia:
+    case linphone::Call::State::IncomingReceived:
+    case linphone::Call::State::OutgoingEarlyMedia:
+    case linphone::Call::State::OutgoingRinging:
+    case linphone::Call::State::Paused:
+    case linphone::Call::State::PausedByRemote:
+    case linphone::Call::State::Pausing:
+    case linphone::Call::State::Referred:
+    case linphone::Call::State::Released:
+    case linphone::Call::State::Resuming:
+    case linphone::Call::State::StreamsRunning:
+    case linphone::Call::State::UpdatedByRemote:
+    case linphone::Call::State::Updating:
       break; // Nothing.
 
     // 1. Init.
-    case linphone::CallStateOutgoingInit:
+    case linphone::Call::State::OutgoingInit:
       qInfo() << QStringLiteral("Call transfer init.");
       break;
 
     // 2. In progress.
-    case linphone::CallStateOutgoingProgress:
+    case linphone::Call::State::OutgoingProgress:
       qInfo() << QStringLiteral("Call transfer in progress.");
       break;
 
     // 3. Done.
-    case linphone::CallStateConnected:
+    case linphone::Call::State::Connected:
       qInfo() << QStringLiteral("Call transfer succeeded.");
       emit callTransferSucceeded(call);
       break;
 
     // 4. Error.
-    case linphone::CallStateEnd:
-    case linphone::CallStateError:
+    case linphone::Call::State::End:
+    case linphone::Call::State::Error:
       qWarning() << QStringLiteral("Call transfer failed.");
       emit callTransferFailed(call);
       break;
@@ -242,7 +242,7 @@ void CoreHandlers::onVersionUpdateCheckResultReceived (
   const string &version,
   const string &url
 ) {
-  if (result == linphone::VersionUpdateCheckResultNewVersionAvailable)
+  if (result == linphone::VersionUpdateCheckResult::NewVersionAvailable)
     App::getInstance()->getNotifier()->notifyNewVersionAvailable(
       ::Utils::coreStringToAppString(version),
       ::Utils::coreStringToAppString(url)

src/components/core/CoreHandlers.hpp

@@ -42,12 +42,12 @@ public:
 
 signals:
   void authenticationRequested (const std::shared_ptr<linphone::AuthInfo> &authInfo);
-  void callStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::CallState state);
+  void callStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::Call::State state);
   void callTransferFailed (const std::shared_ptr<linphone::Call> &call);
   void callTransferSucceeded (const std::shared_ptr<linphone::Call> &call);
   void coreStarted ();
   void isComposingChanged (const std::shared_ptr<linphone::ChatRoom> &chatRoom);
-  void logsUploadStateChanged (linphone::CoreLogCollectionUploadState state, const std::string &info);
+  void logsUploadStateChanged (linphone::Core::LogCollectionUploadState state, const std::string &info);
   void messageReceived (const std::shared_ptr<linphone::ChatMessage> &message);
   void presenceReceived (const QString &sipAddress, const std::shared_ptr<const linphone::PresenceModel> &presenceModel);
   void registrationStateChanged (const std::shared_ptr<linphone::ProxyConfig> &proxyConfig, linphone::RegistrationState state);
@@ -69,7 +69,7 @@ private:
   void onCallStateChanged (
     const std::shared_ptr<linphone::Core> &core,
     const std::shared_ptr<linphone::Call> &call,
-    linphone::CallState state,
+    linphone::Call::State state,
     const std::string &message
   ) override;
 
@@ -92,7 +92,7 @@ private:
 
   void onLogCollectionUploadStateChanged (
     const std::shared_ptr<linphone::Core> &core,
-    linphone::CoreLogCollectionUploadState state,
+    linphone::Core::LogCollectionUploadState state,
     const std::string &info
   ) override;
 
@@ -130,7 +130,7 @@ private:
   void onTransferStateChanged (
     const std::shared_ptr<linphone::Core> &core,
     const std::shared_ptr<linphone::Call> &call,
-    linphone::CallState state
+    linphone::Call::State state
   ) override;
 
   void onVersionUpdateCheckResultReceived (

src/components/core/CoreManager.cpp

@@ -253,13 +253,13 @@ void CoreManager::iterate () {
 
 // -----------------------------------------------------------------------------
 
-void CoreManager::handleLogsUploadStateChanged (linphone::CoreLogCollectionUploadState state, const string &info) {
+void CoreManager::handleLogsUploadStateChanged (linphone::Core::LogCollectionUploadState state, const string &info) {
   switch (state) {
-    case linphone::CoreLogCollectionUploadStateInProgress:
+    case linphone::Core::LogCollectionUploadState::InProgress:
       break;
 
-    case linphone::CoreLogCollectionUploadStateDelivered:
-    case linphone::CoreLogCollectionUploadStateNotDelivered:
+    case linphone::Core::LogCollectionUploadState::Delivered:
+    case linphone::Core::LogCollectionUploadState::NotDelivered:
       emit logsUploaded(::Utils::coreStringToAppString(info));
       break;
   }

src/components/core/CoreManager.hpp

@@ -148,7 +148,7 @@ private:
 
   void iterate ();
 
-  void handleLogsUploadStateChanged (linphone::CoreLogCollectionUploadState state, const std::string &info);
+  void handleLogsUploadStateChanged (linphone::Core::LogCollectionUploadState state, const std::string &info);
 
   static QString getDownloadUrl ();
 

src/components/presence/Presence.hpp

@@ -36,10 +36,10 @@ class Presence : public QObject {
 
 public:
   enum PresenceStatus {
-    Online = linphone::ConsolidatedPresenceOnline,
-    Busy = linphone::ConsolidatedPresenceBusy,
-    DoNotDisturb = linphone::ConsolidatedPresenceDoNotDisturb,
-    Offline = linphone::ConsolidatedPresenceOffline
+    Online = int(linphone::ConsolidatedPresence::Online),
+    Busy = int(linphone::ConsolidatedPresence::Busy),
+    DoNotDisturb = int(linphone::ConsolidatedPresence::DoNotDisturb),
+    Offline = int(linphone::ConsolidatedPresence::Offline)
   };
 
   Q_ENUM(PresenceStatus);

src/components/settings/AccountSettingsModel.cpp

@@ -32,15 +32,15 @@ using namespace std;
 
 static inline AccountSettingsModel::RegistrationState mapLinphoneRegistrationStateToUi (linphone::RegistrationState state) {
   switch (state) {
-    case linphone::RegistrationStateNone:
-    case linphone::RegistrationStateCleared:
-    case linphone::RegistrationStateFailed:
+    case linphone::RegistrationState::None:
+    case linphone::RegistrationState::Cleared:
+    case linphone::RegistrationState::Failed:
       return AccountSettingsModel::RegistrationStateNotRegistered;
 
-    case linphone::RegistrationStateProgress:
+    case linphone::RegistrationState::Progress:
       return AccountSettingsModel::RegistrationStateInProgress;
 
-    case linphone::RegistrationStateOk:
+    case linphone::RegistrationState::Ok:
       break;
   }
 
@@ -105,7 +105,7 @@ QVariantMap AccountSettingsModel::getProxyConfigDescription (const shared_ptr<li
   map["avpfInterval"] = proxyConfig->getAvpfRrInterval();
   map["registerEnabled"] = proxyConfig->registerEnabled();
   map["publishPresence"] = proxyConfig->publishEnabled();
-  map["avpfEnabled"] = proxyConfig->getAvpfMode() == linphone::AVPFMode::AVPFModeEnabled;
+  map["avpfEnabled"] = proxyConfig->getAvpfMode() == linphone::AVPFMode::Enabled;
   map["registrationState"] = ::mapLinphoneRegistrationStateToUi(proxyConfig->getState());
 
   return map;
@@ -168,8 +168,8 @@ bool AccountSettingsModel::addOrUpdateProxyConfig (
   proxyConfig->enableRegister(data["registerEnabled"].toBool());
   proxyConfig->enablePublish(data["publishPresence"].toBool());
   proxyConfig->setAvpfMode(data["avpfEnabled"].toBool()
-    ? linphone::AVPFMode::AVPFModeEnabled
-    : linphone::AVPFMode::AVPFModeDefault
+    ? linphone::AVPFMode::Enabled
+    : linphone::AVPFMode::Default
   );
 
   return addOrUpdateProxyConfig(proxyConfig);

src/components/settings/SettingsModel.cpp

@@ -306,13 +306,13 @@ QVariantList SettingsModel::getSupportedMediaEncryptions () const {
   shared_ptr<linphone::Core> core = CoreManager::getInstance()->getCore();
   QVariantList list;
 
-  if (core->mediaEncryptionSupported(linphone::MediaEncryptionDTLS))
+  if (core->mediaEncryptionSupported(linphone::MediaEncryption::DTLS))
     list << ::buildEncryptionDescription(MediaEncryptionDtls, "DTLS");
 
-  if (core->mediaEncryptionSupported(linphone::MediaEncryptionSRTP))
+  if (core->mediaEncryptionSupported(linphone::MediaEncryption::SRTP))
     list << ::buildEncryptionDescription(MediaEncryptionSrtp, "SRTP");
 
-  if (core->mediaEncryptionSupported(linphone::MediaEncryptionZRTP))
+  if (core->mediaEncryptionSupported(linphone::MediaEncryption::ZRTP))
     list << ::buildEncryptionDescription(MediaEncryptionZrtp, "ZRTP");
 
   return list;

src/components/settings/SettingsModel.hpp

@@ -132,18 +132,18 @@ class SettingsModel : public QObject {
 
 public:
   enum MediaEncryption {
-    MediaEncryptionNone = linphone::MediaEncryptionNone,
-    MediaEncryptionDtls = linphone::MediaEncryptionDTLS,
-    MediaEncryptionSrtp = linphone::MediaEncryptionSRTP,
-    MediaEncryptionZrtp = linphone::MediaEncryptionZRTP
+    MediaEncryptionNone = int(linphone::MediaEncryption::None),
+    MediaEncryptionDtls = int(linphone::MediaEncryption::DTLS),
+    MediaEncryptionSrtp = int(linphone::MediaEncryption::SRTP),
+    MediaEncryptionZrtp = int(linphone::MediaEncryption::ZRTP)
   };
 
   Q_ENUM(MediaEncryption);
 
   enum LimeState {
-    LimeStateDisabled = linphone::LimeStateDisabled,
-    LimeStateMandatory = linphone::LimeStateMandatory,
-    LimeStatePreferred = linphone::LimeStatePreferred
+    LimeStateDisabled = int(linphone::LimeState::Disabled),
+    LimeStateMandatory = int(linphone::LimeState::Mandatory),
+    LimeStatePreferred = int(linphone::LimeState::Preferred)
   };
 
   Q_ENUM(LimeState);

src/components/sip-addresses/SipAddressesModel.cpp

@@ -136,13 +136,13 @@ QString SipAddressesModel::getTransportFromSipAddress (const QString &sipAddress
     return QString("");
 
   switch (address->getTransport()) {
-    case linphone::TransportTypeUdp:
+    case linphone::TransportType::Udp:
       return QStringLiteral("UDP");
-    case linphone::TransportTypeTcp:
+    case linphone::TransportType::Tcp:
       return QStringLiteral("TCP");
-    case linphone::TransportTypeTls:
+    case linphone::TransportType::Tls:
       return QStringLiteral("TLS");
-    case linphone::TransportTypeDtls:
+    case linphone::TransportType::Dtls:
       return QStringLiteral("DTLS");
   }
 
@@ -278,13 +278,13 @@ void SipAddressesModel::handleMessageReceived (const shared_ptr<linphone::ChatMe
 
 void SipAddressesModel::handleCallStateChanged (
   const shared_ptr<linphone::Call> &call,
-  linphone::CallState state
+  linphone::Call::State state
 ) {
   // Ignore aborted calls.
-  if (call->getCallLog()->getStatus() == linphone::CallStatus::CallStatusAborted)
+  if (call->getCallLog()->getStatus() == linphone::Call::Status::Aborted)
     return;
 
-  if (state == linphone::CallStateEnd || state == linphone::CallStateError)
+  if (state == linphone::Call::State::End || state == linphone::Call::State::Error)
     addOrUpdateSipAddress(
       ::Utils::coreStringToAppString(call->getRemoteAddress()->asStringUriOnly()), call
     );
@@ -297,16 +297,16 @@ void SipAddressesModel::handlePresenceReceived (
   Presence::PresenceStatus status;
 
   switch (presenceModel->getConsolidatedPresence()) {
-    case linphone::ConsolidatedPresenceOnline:
+    case linphone::ConsolidatedPresence::Online:
       status = Presence::PresenceStatus::Online;
       break;
-    case linphone::ConsolidatedPresenceBusy:
+    case linphone::ConsolidatedPresence::Busy:
       status = Presence::PresenceStatus::Busy;
       break;
-    case linphone::ConsolidatedPresenceDoNotDisturb:
+    case linphone::ConsolidatedPresence::DoNotDisturb:
       status = Presence::PresenceStatus::DoNotDisturb;
       break;
-    case linphone::ConsolidatedPresenceOffline:
+    case linphone::ConsolidatedPresence::Offline:
       status = Presence::PresenceStatus::Offline;
       break;
   }
@@ -392,7 +392,7 @@ void SipAddressesModel::addOrUpdateSipAddress (QVariantMap &map, ContactModel *c
 void SipAddressesModel::addOrUpdateSipAddress (QVariantMap &map, const shared_ptr<linphone::Call> &call) {
   const shared_ptr<linphone::CallLog> callLog = call->getCallLog();
 
-  map["timestamp"] = callLog->getStatus() == linphone::CallStatus::CallStatusSuccess
+  map["timestamp"] = callLog->getStatus() == linphone::Call::Status::Success
     ? QDateTime::fromMSecsSinceEpoch((callLog->getStartDate() + callLog->getDuration()) * 1000)
     : QDateTime::fromMSecsSinceEpoch(callLog->getStartDate() * 1000);
 }
@@ -492,7 +492,7 @@ void SipAddressesModel::initSipAddresses () {
     if (addressDone.contains(sipAddress))
       continue; // Already used.
 
-    if (callLog->getStatus() == linphone::CallStatusAborted)
+    if (callLog->getStatus() == linphone::Call::Status::Aborted)
       continue; // Ignore aborted calls.
 
     addressDone << sipAddress;
@@ -501,7 +501,7 @@ void SipAddressesModel::initSipAddresses () {
     map["sipAddress"] = sipAddress;
 
     // The duration can be wrong if status is not success.
-    map["timestamp"] = callLog->getStatus() == linphone::CallStatus::CallStatusSuccess
+    map["timestamp"] = callLog->getStatus() == linphone::Call::Status::Success
       ? QDateTime::fromMSecsSinceEpoch((callLog->getStartDate() + callLog->getDuration()) * 1000)
       : QDateTime::fromMSecsSinceEpoch(callLog->getStartDate() * 1000);
 

src/components/sip-addresses/SipAddressesModel.hpp

@@ -81,7 +81,7 @@ private:
   void handleSipAddressRemoved (ContactModel *contact, const QString &sipAddress);
 
   void handleMessageReceived (const std::shared_ptr<linphone::ChatMessage> &message);
-  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::CallState state);
+  void handleCallStateChanged (const std::shared_ptr<linphone::Call> &call, linphone::Call::State state);
   void handlePresenceReceived (const QString &sipAddress, const std::shared_ptr<const linphone::PresenceModel> &presenceModel);
 
   void handleAllEntriesRemoved (const QString &sipAddress);

src/utils/LinphoneUtils.cpp

@@ -26,11 +26,11 @@
 
 linphone::TransportType LinphoneUtils::stringToTransportType (const QString &transport) {
   if (transport == "TCP")
-    return linphone::TransportType::TransportTypeTcp;
+    return linphone::TransportType::Tcp;
   if (transport == "UDP")
-    return linphone::TransportType::TransportTypeUdp;
+    return linphone::TransportType::Udp;
   if (transport == "TLS")
-    return linphone::TransportType::TransportTypeTls;
+    return linphone::TransportType::Tls;
 
-  return linphone::TransportType::TransportTypeDtls;
+  return linphone::TransportType::Dtls;
 }

linphone @ bff2f9a2

-Subproject commit 1ca73da1cf180f39204df9179d44e5a0baf620ec
+Subproject commit bff2f9a26f46607d7c24128ff045817ec1ce3a29