Line data    Source code

       1              : // SPDX-FileCopyrightText: 2022-2026 Paul Colby <git@colby.id.au>
       2              : // SPDX-License-Identifier: LGPL-3.0-or-later
       3              : 
       4              : #include "infocommand.h"
       5              : #include "../stringliterals_p.h"
       6              : 
       7              : #include <qtpokit/deviceinfoservice.h>
       8              : #include <qtpokit/pokitdevice.h>
       9              : 
      10              : #include <QJsonDocument>
      11              : #include <QJsonObject>
      12              : 
      13              : #include <iostream>
      14              : 
      15              : DOKIT_USE_STRINGLITERALS
      16              : 
      17              : /*!
      18              :  * \class InfoCommand
      19              :  *
      20              :  * The InfoCommand class implements the `info` CLI command.
      21              :  */
      22              : 
      23              : /*!
      24              :  * Construct a new InfoCommand object with \a parent.
      25              :  */
      26         2960 : InfoCommand::InfoCommand(QObject * const parent) : DeviceCommand(parent)
      27         1068 : {
      28              : 
      29         3028 : }
      30              : 
      31          350 : QStringList InfoCommand::requiredOptions(const QCommandLineParser &parser) const
      32          555 : {
      33         1255 :     return DeviceCommand::requiredOptions(parser) + QStringList{
      34         1085 :     };
      35          555 : }
      36              : 
      37          140 : QStringList InfoCommand::supportedOptions(const QCommandLineParser &parser) const
      38          222 : {
      39          362 :     return DeviceCommand::supportedOptions(parser);
      40          222 : }
      41              : 
      42              : /*!
      43              :  * \copybrief DeviceCommand::processOptions
      44              :  *
      45              :  * This implementation extends DeviceCommand::processOptions to process additional CLI options
      46              :  * supported (or required) by this command.
      47              :  */
      48           70 : QStringList InfoCommand::processOptions(const QCommandLineParser &parser)
      49          111 : {
      50          181 :     QStringList errors = DeviceCommand::processOptions(parser);
      51          111 :     if (!errors.isEmpty()) {
      52            0 :         return errors;
      53            0 :     }
      54              : 
      55          111 :     return errors;
      56          111 : }
      57              : 
      58              : /*!
      59              :  * \copybrief DeviceCommand::getService
      60              :  *
      61              :  * This override returns a pointer to a DeviceInfoService object.
      62              :  */
      63            0 : AbstractPokitService * InfoCommand::getService()
      64            0 : {
      65            0 :     Q_ASSERT(device);
      66            0 :     if (!service) {
      67            0 :         service = device->deviceInformation();
      68            0 :         Q_ASSERT(service);
      69            0 :     }
      70            0 :     return service;
      71            0 : }
      72              : 
      73              : /*!
      74              :  * \copybrief DeviceCommand::serviceDetailsDiscovered
      75              :  *
      76              :  * This override fetches the current device's information, and outputs it in the selected format.
      77              :  */
      78         1680 : void InfoCommand::serviceDetailsDiscovered()
      79          624 : {
      80         2304 :     DeviceCommand::serviceDetailsDiscovered(); // Just logs consistently.
      81         2304 :     const QLowEnergyController * const controller = (device) ? device->controller() : nullptr;
      82         2304 :     const QString deviceName = (controller) ? controller->remoteName() : QString();
      83         2304 :     const QBluetoothAddress deviceAddress = (controller) ? controller->remoteAddress() : QBluetoothAddress();
      84         2304 :     const QBluetoothUuid deviceUuid = (controller) ? controller->remoteDeviceUuid() : QBluetoothUuid();
      85         2304 :     const QString serialNumber = service->serialNumber();
      86         2304 :     switch (format) {
      87          768 :     case OutputFormat::Csv:
      88         1136 :         std::cout << qUtf8Printable(tr("device_name,device_address,device_uuid,manufacturer_name,model_number,"
      89          208 :                             "hardware_revision,firmware_revision,software_revision,serial_number\n"));
      90         3865 :         std::cout << qUtf8Printable(QString::fromLatin1("%1,%2,%3,%4,%5,%6,%7,%8,%9\n").arg(
      91          208 :             escapeCsvField(deviceName),
      92          208 :             (deviceAddress.isNull()) ? QString() : deviceAddress.toString(),
      93          208 :             (deviceUuid.isNull()) ? QString() : deviceUuid.toString(),
      94          208 :             escapeCsvField(service->manufacturer()), escapeCsvField(service->modelNumber()),
      95          208 :             escapeCsvField(service->hardwareRevision()), escapeCsvField(service->firmwareRevision()),
      96          208 :             escapeCsvField(service->softwareRevision()), escapeCsvField(serialNumber)));
      97          768 :         break;
      98          768 :     case OutputFormat::Json: {
      99          208 :         QJsonObject jsonObject{
     100         1328 :             { u"manufacturerName"_s, service->manufacturer() },
     101         1328 :             { u"modelNumber"_s,      service->modelNumber() },
     102         1328 :             { u"hardwareRevision"_s, service->hardwareRevision() },
     103         1328 :             { u"firmwareRevision"_s, service->firmwareRevision() },
     104         1328 :             { u"softwareRevision"_s, service->softwareRevision() },
     105         5648 :         };
     106          768 :         if (!deviceName.isEmpty()) {
     107         1358 :             jsonObject.insert(u"deviceName"_s, deviceName);
     108          182 :         }
     109          768 :         if (!deviceAddress.isNull()) {
     110          227 :             jsonObject.insert(u"deviceAddress"_s, deviceAddress.toString());
     111           26 :         }
     112          648 :         if (!deviceUuid.isNull()) {
     113          808 :             jsonObject.insert(u"deviceUuid"_s, deviceUuid.toString());
     114           84 :         }
     115          768 :         if (!serialNumber.isNull()) {
     116            0 :             jsonObject.insert(u"serialNumber"_s, serialNumber);
     117            0 :         }
     118         1328 :         std::cout << QJsonDocument(jsonObject).toJson().toStdString();
     119          768 :     }   break;
     120          208 :     case OutputFormat::Text:
     121          768 :         if (!deviceName.isEmpty()) {
     122         1484 :             std::cout << qUtf8Printable(tr("Device name:       %1\n").arg(deviceName));
     123          182 :         }
     124          768 :         if (!deviceAddress.isNull()) {
     125          227 :             std::cout << qUtf8Printable(tr("Device address:    %1\n").arg(deviceAddress.toString()));
     126           26 :         }
     127          648 :         if (!deviceUuid.isNull()) {
     128          808 :             std::cout << qUtf8Printable(tr("Device UUID:       %1\n").arg(deviceUuid.toString()));
     129           84 :         }
     130         1816 :         std::cout << qUtf8Printable(tr("Manufacturer name: %1\n").arg(service->manufacturer()));
     131         1816 :         std::cout << qUtf8Printable(tr("Model number:      %1\n").arg(service->modelNumber()));
     132         1816 :         std::cout << qUtf8Printable(tr("Hardware revision: %1\n").arg(service->hardwareRevision()));
     133         1816 :         std::cout << qUtf8Printable(tr("Firmware revision: %1\n").arg(service->firmwareRevision()));
     134         1816 :         std::cout << qUtf8Printable(tr("Software revision: %1\n").arg(service->softwareRevision()));
     135          768 :         if (!serialNumber.isNull()) {
     136            0 :             std::cout << qUtf8Printable(tr("Serial number:     %1\n").arg(serialNumber));
     137            0 :         }
     138          208 :         break;
     139          624 :     }
     140         2304 :     if (device) disconnect(); // Will exit the application once disconnected.
     141         5232 : }