File indexing completed on 2024-05-05 17:32:29

 // SPDX-FileCopyrightText: 2021 Nicolas Fella <nicolas.fella@gmx.de>
 //
 // SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 
 #include "modemcontroller.h"
 
 #include <ModemManagerQt/Manager>
 
 ModemController &ModemController::instance()
 {
     static ModemController instance;
     return instance;
 }
 
 ModemController::ModemController()
     : QObject()
 {
     connect(ModemManager::notifier(), &ModemManager::Notifier::modemAdded, this, [this](const QString &udi) {
         init(udi);
     });
 }
 
 std::optional<QDBusPendingReply<QDBusObjectPath>> ModemController::createMessage(ModemManager::ModemMessaging::Message m)
 {
     if (!m_msgManager) {
         return {};
     }
 
     return m_msgManager->createMessage(m);
 }
 
 void ModemController::init(std::optional<QString> modemPath)
 {
     if (modemPath) {
         m_modem = ModemManager::findModemDevice(*modemPath);
     } else {
         ModemManager::ModemDevice::List devices = ModemManager::modemDevices();
         if (!devices.isEmpty()) {
             m_modem = devices.first();
         }
     }
 
     if (!m_modem) {
         qWarning() << "Could not find modem" << modemPath.value_or(QString());
         return;
     }
 
     if (m_modem->hasInterface(ModemManager::ModemDevice::GsmInterface)) {
         m_modem3gpp = m_modem->interface(ModemManager::ModemDevice::GsmInterface).objectCast<ModemManager::Modem3gpp>();
         countryCode = m_modem3gpp->countryCode();
         qDebug() << "Country Code:" << countryCode;
 
         connect(m_modem3gpp.get(), &ModemManager::Modem3gpp::countryCodeChanged, this, [this](const QString &code) {
             countryCode = code;
             Q_EMIT countryCodeChanged(code);
             qDebug() << "country code changed" << code;
         });
 
         if (countryCode.isEmpty()) {
             qWarning() << "Country code is null! Phone numbers may not be interpreted correctly";
         }
     }
 
     m_interface = m_modem->modemInterface();
 
     connect(m_interface.get(), &ModemManager::Modem::bearerAdded, this, [this](const QString &bearer) {
         m_bearer = m_interface->findBearer(bearer);
 
         QList<QSharedPointer<ModemManager::Bearer>> bearers = m_interface->listBearers();
         for (const ModemManager::Bearer::Ptr &item : bearers) {
             if (item->uni() != bearer) {
                 item->disconnect();
                 m_interface->deleteBearer(item->uni());
             }
         }
 
         // whether or not the bearer is connected and thus whether packet data communication using this bearer is possible
         connect(m_bearer.data(), &ModemManager::Bearer::connectedChanged, this, [this](bool isConnected) {
             Q_EMIT modemDataConnectedChanged(isConnected);
             qDebug() << "bearer connected:" << isConnected;
         });
 
         // In some devices, packet data service will be suspended while the device is handling other communication, like a voice call
         connect(m_bearer.data(), &ModemManager::Bearer::suspendedChanged, this, [this](bool isSuspended) {
             Q_EMIT modemDataConnectedChanged(!isSuspended);
             qDebug() << "bearer suspended:" << isSuspended;
         });
 
         dnsServers = getDNS(m_bearer);
         qDebug() << "dns:" << dnsServers;
         connect(m_bearer.data(), &ModemManager::Bearer::ip4ConfigChanged, this, [this, bearers](const ModemManager::IpConfig &ipv4Config) {
             dnsServers = getDNS(m_bearer);
             qDebug() << "dns4 updated:" << dnsServers;
         });
 
         connect(m_bearer.data(), &ModemManager::Bearer::ip6ConfigChanged, this, [this, bearers](const ModemManager::IpConfig &ipv6Config) {
             dnsServers = getDNS(m_bearer);
             qDebug() << "dns6 updated:" << dnsServers;
         });
 
         ifaceName = m_bearer->interface();
         qDebug() << "interface:" << ifaceName;
         connect(m_bearer.data(), &ModemManager::Bearer::interfaceChanged, this, [this](const QString &iface) {
             ifaceName = iface;
             qDebug() << "interface changed:" << ifaceName;
         });
     });
 
     connect(m_modem.get(), &ModemManager::ModemDevice::interfaceAdded, this, [this](ModemManager::ModemDevice::InterfaceType type) {
         if (type == ModemManager::ModemDevice::MessagingInterface) {
             initMessaging();
         }
     });
 
     if (m_modem->hasInterface(ModemManager::ModemDevice::MessagingInterface)) {
         initMessaging();
     }
 
     connect(m_interface.get(), &ModemManager::Modem::stateChanged, this, [this](MMModemState oldState, MMModemState newState, MMModemStateChangeReason reason) {
         Q_UNUSED(oldState);
         Q_UNUSED(reason);
         if (newState == MMModemState::MM_MODEM_STATE_CONNECTED) {
             Q_EMIT modemConnected();
             Q_EMIT modemDataConnectedChanged(m_bearer ? m_bearer->isConnected() : false);
         }
     });
 }
 
 void ModemController::initMessaging()
 {
     Q_ASSERT(m_modem);
     Q_ASSERT(m_modem->hasInterface(ModemManager::ModemDevice::MessagingInterface));
 
     m_msgManager = m_modem->messagingInterface();
 
     connect(m_msgManager.get(), &ModemManager::ModemMessaging::messageAdded, this, &ModemController::slotMessageAdded, Qt::UniqueConnection);
 
     Q_EMIT modemConnected();
 }
 
 void ModemController::slotMessageAdded(const QString &uni, bool received)
 {
     // true if the message was received from the network, as opposed to being added locally
     if (!received) {
         return;
     }
 
     ModemManager::Sms::Ptr msg = m_msgManager->findMessage(uni);
     Q_ASSERT(msg);
 
     if (msg->state() == MMSmsState::MM_SMS_STATE_RECEIVING) {
         connect(msg.get(), &ModemManager::Sms::dataChanged, this, [this, msg]() {
             if (msg->state() == MMSmsState::MM_SMS_STATE_RECEIVED) {
                 if (!msg->data().isEmpty()) {
                     Q_EMIT messageAdded(msg);
                 }
             }
         });
         connect(msg.get(), &ModemManager::Sms::textChanged, this, [this, msg]() {
             if (msg->state() == MMSmsState::MM_SMS_STATE_RECEIVED) {
                 if (!msg->text().isEmpty()) {
                     Q_EMIT messageAdded(msg);
                 }
             }
         });
     } else {
         Q_EMIT messageAdded(msg);
     }
 }
 
 void ModemController::deleteMessage(const QString &uni)
 {
     if (!m_msgManager) {
         return;
     }
 
     m_msgManager->deleteMessage(uni);
 }
 
 ModemManager::Sms::List ModemController::messages()
 {
     if (!m_msgManager) {
         ModemManager::Sms::List list;
         return list;
     }
 
     return m_msgManager->messages();
 }
 
 QString ModemController::ownNumber()
 {
     if (!m_interface) {
         return QString();
     }
 
     const QStringList numbers = m_interface->ownNumbers();
 
     if (!numbers.isEmpty()) {
         if (numbers.startsWith(QStringLiteral("+"))) {
             return numbers.first();
         }
         return QStringLiteral("+") + numbers.first();
     }
 
     return QString();
 }
 
 QString ModemController::getDNS(QSharedPointer<ModemManager::Bearer> bearer)
 {
     QStringList dnsServerList = {bearer->ip4Config().dns1(),
                                  bearer->ip4Config().dns2(),
                                  bearer->ip4Config().dns3(),
                                  bearer->ip6Config().dns1(),
                                  bearer->ip6Config().dns2(),
                                  bearer->ip6Config().dns3()};
 
     // remove empty items
     dnsServerList.removeAll(QString());
 
     return dnsServerList.join(QStringLiteral(","));
 }