[JVM] Add printers info

2026-02-24 07:25:11 +01:00
parent 31149f9d1e
commit 9ecdb6da75
7 changed files with 188 additions and 91 deletions
@@ -165,6 +165,13 @@
    <string name="hardware_motherboard">Základní deska</string>
    <string name="hardware_network_interfaces">Síťové rozhraní</string>
    <string name="hardware_power_sources">Zdroje energie</string>
+    <string name="hardware_printers">Tiskárny</string>
+    <string name="hardware_printers_status">Stav: %1$s\nVýchozí: %2$s\nLokální: %3$s\nPort: %4$s</string>
+    <string name="hardware_printers_status_idle">Nečinná</string>
+    <string name="hardware_printers_status_printing">Tisk</string>
+    <string name="hardware_printers_status_error">Chyba</string>
+    <string name="hardware_printers_status_offline">Offline</string>
+    <string name="hardware_printers_status_unknown">Neznámý</string>

    <string name="general">Obecné</string>
    <string name="temperature_unit">Jednotka teploty</string>
@@ -165,6 +165,13 @@
    <string name="hardware_motherboard">Motherboard</string>
    <string name="hardware_network_interfaces">Netzwerkschnittstellen</string>
    <string name="hardware_power_sources">Stromquellen</string>
+    <string name="hardware_printers">Drucker</string>
+    <string name="hardware_printers_status">Status: %1$s\nStandard: %2$s\nLokal: %3$s\nAnschluss: %4$s</string>
+    <string name="hardware_printers_status_idle">Bereit</string>
+    <string name="hardware_printers_status_printing">Druckt</string>
+    <string name="hardware_printers_status_error">Fehler</string>
+    <string name="hardware_printers_status_offline">Offline</string>
+    <string name="hardware_printers_status_unknown">Unbekannt</string>

    <string name="general">Allgemein</string>
    <string name="temperature_unit">Temperatureinheit</string>
@@ -171,6 +171,13 @@
    <string name="hardware_motherboard">Placa base</string>
    <string name="hardware_network_interfaces">Interfaces de red</string>
    <string name="hardware_power_sources">Fuentes de alimentación</string>
+    <string name="hardware_printers">Impresoras</string>
+    <string name="hardware_printers_status">Estado: %1$s\nPredeterminada: %2$s\nLocal: %3$s\nPuerto: %4$s</string>
+    <string name="hardware_printers_status_idle">Inactiva</string>
+    <string name="hardware_printers_status_printing">Imprimiendo</string>
+    <string name="hardware_printers_status_error">Error</string>
+    <string name="hardware_printers_status_offline">Sin conexión</string>
+    <string name="hardware_printers_status_unknown">Desconocido</string>

    <!--Prefs-->
    <string name="general">General</string>
@@ -172,6 +172,13 @@
    <string name="hardware_motherboard">Płyta główna</string>
    <string name="hardware_network_interfaces">Interfejsy sieciowe</string>
    <string name="hardware_power_sources">Źródła zasilania</string>
+    <string name="hardware_printers">Drukarki</string>
+    <string name="hardware_printers_status">Status: %1$s\nDomyślna: %2$s\nLokalna: %3$s\nPort: %4$s</string>
+    <string name="hardware_printers_status_idle">Bezczynna</string>
+    <string name="hardware_printers_status_printing">Drukowanie</string>
+    <string name="hardware_printers_status_error">Błąd</string>
+    <string name="hardware_printers_status_offline">Offline</string>
+    <string name="hardware_printers_status_unknown">Nieznany</string>

    <!--Prefs-->
    <string name="general">Ogólne</string>
@@ -213,6 +213,13 @@
    <string name="hardware_camera_orientation_format" translatable="false">\t\t%1$s</string>
    <string name="hardware_sound_card_format" translatable="false">\t%1$s %2$s</string>
    <string name="hardware_camera_lens_format" translatable="false">\t\t%1$s</string>
+    <string name="hardware_printers">Printers</string>
+    <string name="hardware_printers_status">Status: %1$s\nDefault: %2$s\nLocal: %3$s\nPort: %4$s</string>
+    <string name="hardware_printers_status_idle">Idle</string>
+    <string name="hardware_printers_status_printing">Printing</string>
+    <string name="hardware_printers_status_error">Error</string>
+    <string name="hardware_printers_status_offline">Offline</string>
+    <string name="hardware_printers_status_unknown">Unknown</string>

    <!--Prefs-->
    <string name="general">General</string>
@@ -39,6 +39,6 @@ class GetHardwareDataInteractor(
    }

    companion object {
-        private const val REFRESH_DELAY = 5000L
+        private const val REFRESH_DELAY = 3000L
    }
 }
@@ -23,15 +23,25 @@ import com.kgurgul.cpuinfo.shared.hardware_firmware
 import com.kgurgul.cpuinfo.shared.hardware_motherboard
 import com.kgurgul.cpuinfo.shared.hardware_network_interfaces
 import com.kgurgul.cpuinfo.shared.hardware_power_sources
+import com.kgurgul.cpuinfo.shared.hardware_printers
+import com.kgurgul.cpuinfo.shared.hardware_printers_status
+import com.kgurgul.cpuinfo.shared.hardware_printers_status_error
+import com.kgurgul.cpuinfo.shared.hardware_printers_status_idle
+import com.kgurgul.cpuinfo.shared.hardware_printers_status_offline
+import com.kgurgul.cpuinfo.shared.hardware_printers_status_printing
+import com.kgurgul.cpuinfo.shared.hardware_printers_status_unknown
 import com.kgurgul.cpuinfo.shared.hardware_uuid
 import com.kgurgul.cpuinfo.shared.manufacturer
 import com.kgurgul.cpuinfo.shared.model
 import com.kgurgul.cpuinfo.shared.serial
 import com.kgurgul.cpuinfo.shared.sound_card
 import com.kgurgul.cpuinfo.shared.temperature
+import com.kgurgul.cpuinfo.utils.ResourceUtils
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import oshi.SystemInfo
+import oshi.hardware.HardwareAbstractionLayer
+import oshi.hardware.Printer

 actual class HardwareDataProvider actual constructor() : KoinComponent {

@@ -42,104 +52,156 @@ actual class HardwareDataProvider actual constructor() : KoinComponent {
    actual suspend fun getData(): List<ItemValue> {
        val hardware = systemInfo.hardware
        return buildList {
-            add(ItemValue.NameResource(Res.string.hardware_computer_system, ""))
-            add(
-                ItemValue.NameResource(
-                    Res.string.manufacturer,
-                    hardware.computerSystem.manufacturer,
-                )
-            )
-            add(ItemValue.NameResource(Res.string.model, hardware.computerSystem.model))
-            add(ItemValue.NameResource(Res.string.serial, hardware.computerSystem.serialNumber))
-            add(
-                ItemValue.NameResource(
-                    Res.string.hardware_uuid,
-                    hardware.computerSystem.hardwareUUID,
-                )
-            )
-            val firmware =
-                buildString {
-                        if (hardware.computerSystem.firmware.manufacturer != UNKNOWN) {
-                            append(hardware.computerSystem.firmware.manufacturer)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.firmware.name != UNKNOWN) {
-                            append(hardware.computerSystem.firmware.name)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.firmware.version != UNKNOWN) {
-                            append(hardware.computerSystem.firmware.version)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.firmware.description != UNKNOWN) {
-                            append(hardware.computerSystem.firmware.description)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.firmware.releaseDate != UNKNOWN) {
-                            append(hardware.computerSystem.firmware.releaseDate)
-                        }
-                    }
-                    .trim()
-            val motherboard =
-                buildString {
-                        if (hardware.computerSystem.baseboard.manufacturer != UNKNOWN) {
-                            append(hardware.computerSystem.baseboard.manufacturer)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.baseboard.model != UNKNOWN) {
-                            append(hardware.computerSystem.baseboard.model)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.baseboard.version != UNKNOWN) {
-                            append(hardware.computerSystem.baseboard.version)
-                            append(" ")
-                        }
-                        if (hardware.computerSystem.baseboard.serialNumber != UNKNOWN) {
-                            append(hardware.computerSystem.baseboard.serialNumber)
-                        }
-                    }
-                    .trim()
-            add(ItemValue.NameResource(Res.string.hardware_firmware, firmware))
-            add(ItemValue.NameResource(Res.string.hardware_motherboard, motherboard))
+            addMainHardwareInfo(hardware)
+            addSoundCardInfo(hardware)
+            addNetworkInfo(hardware)
+            addPowerSourceInfo(hardware)
+            addPrintersInfo(hardware)
+        }
+    }

-            if (hardware.soundCards.isNotEmpty()) {
-                add(ItemValue.NameResource(Res.string.sound_card, ""))
-                hardware.soundCards.forEach { soundCard ->
-                    add(ItemValue.Text(soundCard.name, soundCard.driverVersion))
+    private fun MutableList<ItemValue>.addMainHardwareInfo(hardware: HardwareAbstractionLayer) {
+        add(ItemValue.NameResource(Res.string.hardware_computer_system, ""))
+        add(ItemValue.NameResource(Res.string.manufacturer, hardware.computerSystem.manufacturer))
+        add(ItemValue.NameResource(Res.string.model, hardware.computerSystem.model))
+        add(ItemValue.NameResource(Res.string.serial, hardware.computerSystem.serialNumber))
+        add(ItemValue.NameResource(Res.string.hardware_uuid, hardware.computerSystem.hardwareUUID))
+        val firmware =
+            buildString {
+                    if (hardware.computerSystem.firmware.manufacturer != UNKNOWN) {
+                        append(hardware.computerSystem.firmware.manufacturer)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.firmware.name != UNKNOWN) {
+                        append(hardware.computerSystem.firmware.name)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.firmware.version != UNKNOWN) {
+                        append(hardware.computerSystem.firmware.version)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.firmware.description != UNKNOWN) {
+                        append(hardware.computerSystem.firmware.description)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.firmware.releaseDate != UNKNOWN) {
+                        append(hardware.computerSystem.firmware.releaseDate)
+                    }
                }
-            }
+                .trim()
+        val motherboard =
+            buildString {
+                    if (hardware.computerSystem.baseboard.manufacturer != UNKNOWN) {
+                        append(hardware.computerSystem.baseboard.manufacturer)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.baseboard.model != UNKNOWN) {
+                        append(hardware.computerSystem.baseboard.model)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.baseboard.version != UNKNOWN) {
+                        append(hardware.computerSystem.baseboard.version)
+                        append(" ")
+                    }
+                    if (hardware.computerSystem.baseboard.serialNumber != UNKNOWN) {
+                        append(hardware.computerSystem.baseboard.serialNumber)
+                    }
+                }
+                .trim()
+        add(ItemValue.NameResource(Res.string.hardware_firmware, firmware))
+        add(ItemValue.NameResource(Res.string.hardware_motherboard, motherboard))
+    }

-            if (hardware.networkIFs.isNotEmpty()) {
-                add(ItemValue.NameResource(Res.string.hardware_network_interfaces, ""))
-                hardware.networkIFs.forEach { networkIF ->
-                    val value =
-                        buildString {
-                                appendLine(networkIF.macaddr)
-                                if (networkIF.iPv4addr.isNotEmpty()) {
-                                    appendLine(networkIF.iPv4addr.joinToString { "\n" })
-                                }
-                                if (networkIF.iPv6addr.isNotEmpty()) {
-                                    appendLine(networkIF.iPv6addr.joinToString { "\n" })
-                                }
+    private fun MutableList<ItemValue>.addSoundCardInfo(hardware: HardwareAbstractionLayer) {
+        if (hardware.soundCards.isNotEmpty()) {
+            add(ItemValue.NameResource(Res.string.sound_card, ""))
+            hardware.soundCards.forEach { soundCard ->
+                add(ItemValue.Text(soundCard.name, soundCard.driverVersion))
+            }
+        }
+    }
+
+    private fun MutableList<ItemValue>.addNetworkInfo(hardware: HardwareAbstractionLayer) {
+        if (hardware.networkIFs.isNotEmpty()) {
+            add(ItemValue.NameResource(Res.string.hardware_network_interfaces, ""))
+            hardware.networkIFs.forEach { networkIF ->
+                val value =
+                    buildString {
+                            appendLine(networkIF.macaddr)
+                            if (networkIF.iPv4addr.isNotEmpty()) {
+                                appendLine(networkIF.iPv4addr.joinToString { "\n" })
                            }
-                            .trim()
-                    add(ItemValue.Text(networkIF.name, value))
+                            if (networkIF.iPv6addr.isNotEmpty()) {
+                                appendLine(networkIF.iPv6addr.joinToString { "\n" })
+                            }
+                        }
+                        .trim()
+                add(ItemValue.Text(networkIF.name, value))
+            }
+        }
+    }
+
+    private suspend fun MutableList<ItemValue>.addPowerSourceInfo(
+        hardware: HardwareAbstractionLayer
+    ) {
+        if (hardware.powerSources.isNotEmpty()) {
+            add(ItemValue.NameResource(Res.string.hardware_power_sources, ""))
+            hardware.powerSources.forEach { powerSource ->
+                add(ItemValue.Text(powerSource.name, powerSource.deviceName))
+                if (powerSource.temperature != 0.0) {
+                    add(
+                        ItemValue.NameResource(
+                            Res.string.temperature,
+                            temperatureFormatter.format(powerSource.temperature.toFloat()),
+                        )
+                    )
                }
            }
+        }
+    }

-            if (hardware.powerSources.isNotEmpty()) {
-                add(ItemValue.NameResource(Res.string.hardware_power_sources, ""))
-                hardware.powerSources.forEach { powerSource ->
-                    add(ItemValue.Text(powerSource.name, powerSource.deviceName))
-                    if (powerSource.temperature != 0.0) {
-                        add(
-                            ItemValue.NameResource(
-                                Res.string.temperature,
-                                temperatureFormatter.format(powerSource.temperature.toFloat()),
-                            )
-                        )
+    private fun MutableList<ItemValue>.addPrintersInfo(hardware: HardwareAbstractionLayer) {
+        if (hardware.printers.isNotEmpty()) {
+            add(ItemValue.NameResource(Res.string.hardware_printers, ""))
+            hardware.printers.forEach { printer ->
+                val name =
+                    buildString {
+                            appendLine(printer.name)
+                            if (!printer.driverName.isNullOrEmpty()) {
+                                appendLine(printer.driverName)
+                            }
+                            if (!printer.description.isNullOrEmpty()) {
+                                appendLine(printer.description)
+                            }
+                            if (
+                                !printer.statusReason.isNullOrEmpty() &&
+                                    !printer.statusReason.equals(UNKNOWN, ignoreCase = true)
+                            ) {
+                                appendLine(printer.statusReason)
+                            }
+                        }
+                        .trim()
+                val status =
+                    when (printer.status) {
+                        Printer.PrinterStatus.IDLE -> Res.string.hardware_printers_status_idle
+                        Printer.PrinterStatus.PRINTING ->
+                            Res.string.hardware_printers_status_printing
+                        Printer.PrinterStatus.ERROR -> Res.string.hardware_printers_status_error
+                        Printer.PrinterStatus.OFFLINE -> Res.string.hardware_printers_status_offline
+                        Printer.PrinterStatus.UNKNOWN -> Res.string.hardware_printers_status_unknown
                    }
-                }
+                add(
+                    ItemValue.FormattedValueResource(
+                        name,
+                        Res.string.hardware_printers_status,
+                        listOf(
+                            status,
+                            ResourceUtils.getYesNoStringResource(printer.isDefault),
+                            ResourceUtils.getYesNoStringResource(printer.isLocal),
+                            printer.portName,
+                        ),
+                    )
+                )
            }
        }
    }