/* This file is part of the TDE libraries Copyright (C) 2012 Timothy Pearson This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef _TDEHARDWAREDEVICES_H #define _TDEHARDWAREDEVICES_H // TDE includes #include #include #include #include #include "kiconloader.h" #include "tdelibs_export.h" // udev includes extern "C" { #include } #include #include #include #include /** * Hardware Device Access and Monitoring Library * * @author Timothy Pearson */ class TDENetworkConnectionManager; namespace TDEHardwareEvent { enum TDEHardwareEvent { HardwareListModified, MountTableModified, HardwareAdded, HardwareRemoved, HardwareUpdated, Other, Last = Other }; }; // Keep readGenericDeviceTypeFromString(), getFriendlyDeviceTypeStringFromType(), and getDeviceTypeIconFromType() in tdehardwaredevices.cpp in sync with this enum namespace TDEGenericDeviceType { enum TDEGenericDeviceType { Root, RootSystem, CPU, GPU, RAM, Bus, I2C, MDIO, Mainboard, Disk, SCSI, StorageController, Mouse, Keyboard, HID, Modem, Monitor, Network, Printer, Scanner, Sound, VideoCapture, IEEE1394, PCMCIA, Camera, TextIO, Serial, Parallel, Peripheral, Backlight, Battery, PowerSupply, Dock, ThermalSensor, ThermalControl, BlueTooth, Bridge, Platform, Cryptography, Event, Input, PNP, OtherACPI, OtherUSB, OtherMultimedia, OtherPeripheral, OtherSensor, OtherVirtual, Other, Last = Other }; }; // Keep readDiskDeviceSubtypeFromString() in tdehardwaredevices.cpp in sync with this enum namespace TDEDiskDeviceType { enum TDEDiskDeviceType { Null = 0x00000000, MediaDevice = 0x00000001, Floppy = 0x00000002, CDROM = 0x00000004, CDRW = 0x00000008, DVDROM = 0x00000010, DVDRAM = 0x00000020, DVDRW = 0x00000040, BDROM = 0x00000080, BDRW = 0x00000100, Zip = 0x00000200, Jaz = 0x00000400, Camera = 0x00000800, LUKS = 0x00001000, OtherCrypted = 0x00002000, CDAudio = 0x00004000, CDVideo = 0x00008000, DVDVideo = 0x00010000, BDVideo = 0x00020000, Flash = 0x00040000, USB = 0x00080000, Tape = 0x00100000, HDD = 0x00200000, Optical = 0x00400000, RAM = 0x00800000, Loop = 0x01000000, CompactFlash = 0x02000000, MemoryStick = 0x04000000, SmartMedia = 0x08000000, SDMMC = 0x10000000, UnlockedCrypt = 0x20000000, Other = 0x80000000 }; inline TDEDiskDeviceType operator|(TDEDiskDeviceType a, TDEDiskDeviceType b) { return static_cast(static_cast(a) | static_cast(b)); } inline TDEDiskDeviceType operator&(TDEDiskDeviceType a, TDEDiskDeviceType b) { return static_cast(static_cast(a) & static_cast(b)); } inline TDEDiskDeviceType operator~(TDEDiskDeviceType a) { return static_cast(~static_cast(a)); } }; namespace TDEDiskDeviceStatus { enum TDEDiskDeviceStatus { Null = 0x00000000, Mountable = 0x00000001, Removable = 0x00000002, Inserted = 0x00000004, Blank = 0x00000008, UsedByDevice = 0x00000010, UsesDevice = 0x00000020, ContainsFilesystem = 0x00000040, Hotpluggable = 0x00000080, Other = 0x80000000 }; inline TDEDiskDeviceStatus operator|(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b) { return static_cast(static_cast(a) | static_cast(b)); } inline TDEDiskDeviceStatus operator&(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b) { return static_cast(static_cast(a) & static_cast(b)); } inline TDEDiskDeviceStatus operator~(TDEDiskDeviceStatus a) { return static_cast(~static_cast(a)); } }; class TDECORE_EXPORT TDESensorCluster { public: /** * Constructor. */ TDESensorCluster(); TQString label; double current; double minimum; double maximum; double warning; double critical; }; class TDECORE_EXPORT TDEGenericDevice : public TQObject { Q_OBJECT public: /** * Constructor. * @param Device type */ TDEGenericDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEGenericDevice(); /** * @return a TDEGenericDeviceType::TDEGenericDeviceType specifying the device type */ TDEGenericDeviceType::TDEGenericDeviceType type(); /** * @return a TQString with the device name, if any */ TQString name(); /** * @return a TQString with the vendor name, if any */ TQString vendorName(); /** * @return a TQString with the vendor model, if any */ TQString vendorModel(); /** * @return a TQString with the serial number, if any */ TQString serialNumber(); /** * @return a TQString with a friendly name * * While TDE tries very hard to generate and return a friendly name for this device, * sometimes the best it will be able to do is "Unknown Device [xxxx:yyyy]" */ virtual TQString friendlyName(); /** * @return a TQString with the device bus name, if any */ TQString deviceBus(); /** * @return a TQString with the system path, if any * * This method is non-portable, so be careful! */ TQString systemPath(); /** * @return a TQString with the system device node, if any * * This method is non-portable, so be careful! */ TQString deviceNode(); /** * @return true if this device has been blacklisted for update actions */ bool blacklistedForUpdate(); /** * @return a TQString containing a unique identifier for this device */ TQString uniqueID(); /** * @return a TQString with the vendor ID, if any */ TQString vendorID(); /** * @return a TQString with the model ID, if any */ TQString modelID(); /** * @return a TQString with the encoded vendor, if any */ TQString vendorEncoded(); /** * @return a TQString with the encoded model, if any */ TQString modelEncoded(); /** * @return a TQString with the subvendor ID, if any */ TQString subVendorID(); /** * @return a TQString with the submodel ID, if any */ TQString subModelID(); /** * @return a TQString with the PCI device class, if any */ TQString PCIClass(); /** * @return a TQString with the module alias string, if any */ TQString moduleAlias(); /** * @return a TQString with the device driver, if any */ TQString deviceDriver(); /** * @return a TQString with the subsystem type, if any */ TQString subsystem(); /** * @return a TDEGenericDevice* with the parent device, if any */ TDEGenericDevice* parentDevice(); /** * @return a TQString containing the friendly type name */ virtual TQString friendlyDeviceType(); /** * @return a TQString containing the device bus ID, if any */ TQString busID(); /** * Get an icon for this device * @param size a TDEIcon::StdSizes structure specifying the desired icon size * @return a TQPixmap containing the icon for the specified type */ virtual TQPixmap icon(TDEIcon::StdSizes size); protected: /** * @param a TQString with the device name, if any * @internal */ void internalSetName(TQString dn); /** * @param a TQString with the vendor name, if any * @internal */ void internalSetVendorName(TQString vn); /** * @param a TQString with the vendor model, if any * @internal */ void internalSetVendorModel(TQString vm); /** * @param a TQString with the serial number, if any * @internal */ void internalSetSerialNumber(TQString sn); /** * @param a TQString with the device bus name, if any * @internal */ void internalSetDeviceBus(TQString db); /** * @param a TQString with the system path, if any * @internal * * This method is non-portable, so be careful! */ void internalSetSystemPath(TQString sp); /** * @param a TQString with the system device node, if any * @internal * * This method is non-portable, so be careful! */ void internalSetDeviceNode(TQString sn); /** * @param bl true if this device has been blacklisted for update actions * @internal */ void internalSetBlacklistedForUpdate(bool bl); /** * @param a TQString with the vendor ID, if any * @internal */ void internalSetVendorID(TQString id); /** * @param a TQString with the model ID, if any * @internal */ void internalSetModelID(TQString id); /** * @param a TQString with the encoded vendor, if any * @internal */ void internalSetVendorEncoded(TQString id); /** * @param a TQString with the encoded model, if any * @internal */ void internalSetModelEncoded(TQString id); /** * @param a TQString with the subvendor ID, if any * @internal */ void internalSetSubVendorID(TQString id); /** * @param a TQString with the submodel ID, if any * @internal */ void internalSetSubModelID(TQString id); /** * @param a TQString with the PCI device class, if any * @internal */ void internalSetPCIClass(TQString cl); /** * @param a TQString with the module alias string, if any * @internal */ void internalSetModuleAlias(TQString ma); /** * @param a TQString with the device driver, if any * @internal */ void internalSetDeviceDriver(TQString dr); /** * @param a TQString with the subsystem type, if any * @internal */ void internalSetSubsystem(TQString ss); /** * @param a TDEGenericDevice* with the parent device, if any * @internal */ void internalSetParentDevice(TDEGenericDevice* pd); private: TDEGenericDeviceType::TDEGenericDeviceType m_deviceType; TQString m_deviceName; TQString m_systemPath; TQString m_deviceNode; TQString m_vendorName; TQString m_vendorModel; TQString m_serialNumber; TQString m_deviceBus; TQString m_uniqueID; TQString m_vendorID; TQString m_modelID; TQString m_vendorenc; TQString m_modelenc; TQString m_subvendorID; TQString m_submodelID; TQString m_pciClass; TQString m_modAlias; TQString m_deviceDriver; TQString m_subsystem; TQString m_friendlyName; bool m_blacklistedForUpdate; TDEGenericDevice* m_parentDevice; // Internal use only! TQStringList m_externalSubtype; TQString m_externalRulesFile; TQString m_udevtype; TQString m_udevdevicetypestring; TQString udevdevicetypestring_alt; friend class TDEHardwareDevices; }; typedef TQMap TDEStorageMountOptions; class TDECORE_EXPORT TDEStorageDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEStorageDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEStorageDevice(); /** * @return a TQString with the disk or partition label, if any */ TQString diskLabel(); /** * @return a TQString with the disk UUID, if any */ TQString diskUUID(); /** * @return an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags */ TDEDiskDeviceType::TDEDiskDeviceType diskType(); /** * @return an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags */ TDEDiskDeviceStatus::TDEDiskDeviceStatus diskStatus(); /** * @return true if media inserted, false if no media available */ bool mediaInserted(); /** * @return a TQString with the filesystem name, if any */ TQString fileSystemName(); /** * @return a TQString with the filesystem usage string, if any */ TQString fileSystemUsage(); /** * @return a TQStringList containing system paths to all devices with a lock on this device, if any */ TQStringList holdingDevices(); /** * @return a TQStringList containing system paths to all devices locked by this device, if any */ TQStringList slaveDevices(); /** * Mounts the device if not encrypted * * @param a TQString containing a requested mount name under /media, if desired * @param a TQString containing any mount options for pmount, if desired * @param a pointer to a TQString which will be populated with any error messages from pmount, if desired * @param a pointer to an integer which will be populated with the return code from pmount, if desired * * @return a TQString with the mount path, if successful */ TQString mountDevice(TQString mediaName=TQString::null, TDEStorageMountOptions mountOptions=TDEStorageMountOptions(), TQString* errRet=0, int* retcode=0); /** * Mounts the encrypted device if the correct passphrase is given * * @param a TQString containing the passphrase * @param a TQString containing a requested mount name under /media, if desired * @param a TQString containing any mount options for pmount, if desired * @param a pointer to a TQString which will be populated with any error messages from pmount, if desired * @param a pointer to an integer which will be populated with the return code from pmount, if desired * * @return a TQString with the mount path, if successful */ TQString mountEncryptedDevice(TQString passphrase, TQString mediaName=TQString::null, TDEStorageMountOptions mountOptions=TDEStorageMountOptions(), TQString* errRet=0, int* retcode=0); /** * Unmounts the device * * @param a pointer to a TQString which will be populated with any error messages from pmount, if desired * @param a pointer to an integer which will be populated with the return code from pmount, if desired * * @return TRUE if unmount was successful */ bool unmountDevice(TQString* errRet, int* retcode=0); /** * @return a TQString with the mount path, if mounted */ TQString mountPath(); /** * @return an unsigned long with the device size in bytes */ unsigned long long deviceSize(); /** * @return a TQString with the device size in human readable form */ TQString deviceFriendlySize(); /** * Get an icon for this device * @param size a TDEIcon::StdSizes structure specifying the desired icon size * @return a TQPixmap containing the icon for the specified type * * This method overrides TDEGenericDevice::icon(TDEIcon::StdSizes size) */ TQPixmap icon(TDEIcon::StdSizes size); /** * @return a TQString with a friendly name * * This method overrides TDEGenericDevice::friendlyName() */ TQString friendlyName(); /** * @return a TQString containing the friendly type name * * This method overrides TDEGenericDevice::friendlyDeviceType() */ TQString friendlyDeviceType(); /** * @param an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags */ bool isDiskOfType(TDEDiskDeviceType::TDEDiskDeviceType tf); /** * @param an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags */ bool checkDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus sf); /** * @param TRUE to engage media lock, FALSE to disable it * @return TRUE on success, FALSE on failure * * This method currently works on CD-ROM drives and similar devices */ bool lockDriveMedia(bool lock); /** * @return TRUE on success, FALSE on failure * * This method currently works on CD-ROM drives and similar devices */ bool ejectDriveMedia(); /** * @return TRUE on success, FALSE on failure * * This method currently works on all removable storage devices */ bool ejectDrive(); protected: /** * @param a TQString with the disk or partition label, if any * @internal */ void internalSetDiskLabel(TQString dn); /** * @param a TQString with the disk UUID, if any * @internal */ void internalSetDiskUUID(TQString id); /** * @param an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags * @internal */ void internalSetDiskType(TDEDiskDeviceType::TDEDiskDeviceType tf); /** * @param an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags * @internal */ void internalSetDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus st); /** * @param a bool with the media status * @internal */ void internalSetMediaInserted(bool inserted); /** * @param a TQString with the filesystem name, if any * @internal */ void internalSetFileSystemName(TQString fn); /** * @param a TQString with the filesystem usage string, if any * @internal */ void internalSetFileSystemUsage(TQString fu); /** * @param a TQStringList containing system paths to all devices with a lock on this device, if any * @internal */ void internalSetHoldingDevices(TQStringList hd); /** * @param a TQStringList containing system paths to all devices locked by this device, if any * @internal */ void internalSetSlaveDevices(TQStringList sd); private: TDEDiskDeviceType::TDEDiskDeviceType m_diskType; TDEDiskDeviceStatus::TDEDiskDeviceStatus m_diskStatus; TQString m_diskName; TQString m_diskUUID; TQString m_fileSystemName; TQString m_fileSystemUsage; bool m_mediaInserted; TQString m_mountPath; TQStringList m_holdingDevices; TQStringList m_slaveDevices; friend class TDEHardwareDevices; }; class TDECORE_EXPORT TDECPUDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDECPUDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDECPUDevice(); /** * @return a double with the current CPU frequency in MHz, if available */ double frequency(); /** * @return a double with the minimum CPU frequency in MHz, if available */ double minFrequency(); /** * @return a double with the maximum CPU frequency in MHz, if available */ double maxFrequency(); /** * @return a double with the transition latency in ns, if available */ double transitionLatency(); /** * @return a TQString with the current CPU governor policy, if available */ TQString governor(); /** * @return a TQString with the current CPU scaling driver, if available */ TQString scalingDriver(); /** * @return a TQStringList with the IDs of all processors that are dependent on the frequency/power settings of this one, if available */ TQStringList dependentProcessors(); /** * @return a TQStringList with all valid scaling frequencies in Hz, if available */ TQStringList availableFrequencies(); /** * @return a TQStringList with all available governor policies, if available */ TQStringList availableGovernors(); /** * @return TRUE if permissions allow the CPU governor to be set, FALSE if not */ bool canSetGovernor(); /** * @param gv a TQString with the new CPU governor policy name */ void setGovernor(TQString gv); /** * @return TRUE if permissions allow the CPU maximum frequency to be set, FALSE if not */ bool canSetMaximumScalingFrequency(); /** * @param gv a double with the new CPU maximum frequency in MHz */ void setMaximumScalingFrequency(double fr); /** * @return an integer with the core number, starting at 0 */ int coreNumber(); protected: /** * @param fr a double with the current CPU frequency in MHz, if available * @internal */ void internalSetFrequency(double fr); /** * @param fr a double with the minimum CPU frequency in MHz, if available * @internal */ void internalSetMinFrequency(double fr); /** * @param fr a double with the maximum CPU frequency in MHz, if available * @internal */ void internalSetMaxFrequency(double fr); /** * @param tl a double with the transition latency in ns, if available * @internal */ void internalSetTransitionLatency(double tl); /** * @param gr a TQString with the current CPU governor policy, if available * @internal */ void internalSetGovernor(TQString gr); /** * @param dr a TQString with the current CPU scaling driver, if available * @internal */ void internalSetScalingDriver(TQString dr); /** * @param dp a TQStringList with the IDs of all processors that are dependent on the frequency/power settings of this one, if available * @internal */ void internalSetDependentProcessors(TQStringList dp); /** * @param af a TQStringList with all valid scaling frequencies in Hz, if available * @internal */ void internalSetAvailableFrequencies(TQStringList af); /** * @param gp a TQStringList with all available governor policies, if available * @internal */ void internalSetAvailableGovernors(TQStringList gp); /** * @param cn an integer with the core number, starting at 0 * @internal */ void internalSetCoreNumber(int cn); private: double m_frequency; double m_minfrequency; double m_maxfrequency; double m_transitionlatency; TQString m_governor; TQString m_scalingdriver; TQStringList m_tiedprocs; TQStringList m_frequencies; TQStringList m_governers; int m_corenumber; friend class TDEHardwareDevices; }; namespace TDEBatteryStatus { enum TDEBatteryStatus { Charging, Discharging, Full, Unknown = 0x80000000 }; }; class TDECORE_EXPORT TDEBatteryDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEBatteryDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEBatteryDevice(); /** * @return a double with the current battery voltage, if available */ double voltage(); /** * @return a double with the minimum battery voltage, if available */ double minimumVoltage(); /** * @return a double with the maximum battery voltage, if available */ double maximumVoltage(); /** * @return a double with the designed maximum battery voltage, if available */ double maximumDesignVoltage(); /** * @return a double with the current battery energy in watt-hours, if available */ double energy(); /** * @return a double with the current battery alarm energy in watt-hours, if available */ double alarmEnergy(); /** * @return a double with the maximum battery energy in watt-hours, if available */ double maximumEnergy(); /** * @return a double with the designed maximum battery energy in watt-hours, if available */ double maximumDesignEnergy(); /** * @return a double with the current battery discharge rate in watt-hours, if available */ double dischargeRate(); /** * @return a double with the current battery discharge time remaining in seconds, if available */ double timeRemaining(); /** * @return a TQString with the battery technology, if available */ TQString technology(); /** * @return a TDEBatteryStatus::TDEBatteryStatus with the current battery status */ TDEBatteryStatus::TDEBatteryStatus status(); /** * @return TRUE if the battery is installed */ bool installed(); /** * @return a double with the current battery charge in percent, if available */ double chargePercent(); protected: /** * @param a double with the current battery voltage, if available * @internal */ void internalSetVoltage(double vt); /** * @param a double with the minimum battery voltage, if available * @internal */ void internalSetMinimumVoltage(double vt); /** * @param a double with the maximum battery voltage, if available * @internal */ void internalSetMaximumVoltage(double vt); /** * @param a double with the designed maximum battery voltage, if available * @internal */ void internalSetMaximumDesignVoltage(double vt); /** * @param a double with the current battery energy in watt-hours, if available * @internal */ void internalSetEnergy(double vt); /** * @param a double with the current battery alarm energy in watt-hours, if available * @internal */ void internalSetAlarmEnergy(double vt); /** * @param a double with the maximum battery energy in watt-hours, if available * @internal */ void internalSetMaximumEnergy(double vt); /** * @param a double with the designed maximum battery energy in watt-hours, if available * @internal */ void internalSetMaximumDesignEnergy(double vt); /** * @param a double with the current battery discharge rate in volt-hours, if available * @internal */ void internalSetDischargeRate(double vt); /** * @param a double with the current battery discharge time remaining in seconds, if available * @internal */ void internalSetTimeRemaining(double tr); /** * @param a TQString with the battery technology, if available * @internal */ void internalSetTechnology(TQString tc); /** * @param a TQString with the battery status, if available * @internal */ void internalSetStatus(TQString tc); /** * @param TRUE if the battery is installed * @internal */ void internalSetInstalled(bool tc); private: double m_currentVoltage; double m_minimumVoltage; double m_maximumVoltage; double m_maximumDesignVoltage; double m_alarmEnergy; double m_currentEnergy; double m_maximumEnergy; double m_maximumDesignEnergy; double m_dischargeRate; double m_timeRemaining; TQString m_technology; TDEBatteryStatus::TDEBatteryStatus m_status; bool m_installed; friend class TDEHardwareDevices; }; class TDECORE_EXPORT TDEMainsPowerDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEMainsPowerDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEMainsPowerDevice(); /** * @return TRUE if power supply is online via mains power, FALSE if not */ bool online(); protected: /** * @param TRUE if power supply is online via mains power, FALSE if not * @internal */ void internalSetOnline(bool vt); private: bool m_online; friend class TDEHardwareDevices; }; class TDECORE_EXPORT TDENetworkDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDENetworkDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDENetworkDevice(); /** * @return a TQString containing the network device's MAC address */ TQString macAddress(); /** * @return a TQString containing the network device's operational state */ TQString state(); /** * @return TRUE if carrier is present, FALSE if not */ bool carrierPresent(); /** * @return TRUE if device is dormant, FALSE if not */ bool dormant(); /** * @return a TQString containing the network device's IPv4 address */ TQString ipV4Address(); /** * @return a TQString containing the network device's IPv6 address */ TQString ipV6Address(); /** * @return a TQString containing the network device's IPv4 netmask */ TQString ipV4Netmask(); /** * @return a TQString containing the network device's IPv6 netmask */ TQString ipV6Netmask(); /** * @return a TQString containing the network device's IPv4 broadcast */ TQString ipV4Broadcast(); /** * @return a TQString containing the network device's IPv6 broadcast */ TQString ipV6Broadcast(); /** * @return a TQString containing the network device's IPv4 destination */ TQString ipV4Destination(); /** * @return a TQString containing the network device's IPv6 destination */ TQString ipV6Destination(); /** * @return a double with the number of received bytes, if available */ double rxBytes(); /** * @return a double with the number of transmitted bytes, if available */ double txBytes(); /** * @return a double with the number of received packets, if available */ double rxPackets(); /** * @return a double with the number of transmitted packets, if available */ double txPackets(); /** * @return a pointer to a TDENetworkConnectionManager object, if available */ TDENetworkConnectionManager* connectionManager(); protected: /** * @param ma a TQString containing the network device's MAC address * @internal */ void internalSetMacAddress(TQString ma); /** * @param st a TQString containing the network device's operational state * @internal */ void internalSetState(TQString st); /** * @param TRUE if carrier is present, FALSE if not * @internal */ void internalSetCarrierPresent(bool cp); /** * @param TRUE if device is dormant, FALSE if not * @internal */ void internalSetDormant(bool dm); /** * @param ad a TQString containing the network device's IPv4 address * @internal */ void internalSetIpV4Address(TQString ad); /** * @param ad a TQString containing the network device's IPv6 address * @internal */ void internalSetIpV6Address(TQString ad); /** * @param nm a TQString containing the network device's IPv4 netmask * @internal */ void internalSetIpV4Netmask(TQString nm); /** * @param nm a TQString containing the network device's IPv6 netmask * @internal */ void internalSetIpV6Netmask(TQString nm); /** * @param br a TQString containing the network device's IPv4 broadcast * @internal */ void internalSetIpV4Broadcast(TQString br); /** * @param br a TQString containing the network device's IPv6 broadcast * @internal */ void internalSetIpV6Broadcast(TQString br); /** * @param ds a TQString containing the network device's IPv4 destination * @internal */ void internalSetIpV4Destination(TQString ds); /** * @param ds a TQString containing the network device's IPv6 destination * @internal */ void internalSetIpV6Destination(TQString ds); /** * @param rx a double with the number of received bytes, if available * @internal */ void internalSetRxBytes(double rx); /** * @param tx a double with the number of transmitted bytes, if available * @internal */ void internalSetTxBytes(double tx); /** * @param rx a double with the number of received packets, if available * @internal */ void internalSetRxPackets(double rx); /** * @param tx a double with the number of transmitted packets, if available * @internal */ void internalSetTxPackets(double tx); /** * @param mgr a pointer to a TDENetworkConnectionManager object, if available */ void internalSetConnectionManager(TDENetworkConnectionManager* mgr); private: TQString m_macAddress; TQString m_state; bool m_carrier; bool m_dormant; TQString m_ipV4Address; TQString m_ipV6Address; TQString m_ipV4Netmask; TQString m_ipV6Netmask; TQString m_ipV4Broadcast; TQString m_ipV6Broadcast; TQString m_ipV4Destination; TQString m_ipV6Destination; double m_rxbytes; double m_txbytes; double m_rxpackets; double m_txpackets; TDENetworkConnectionManager* m_connectionManager; friend class TDEHardwareDevices; }; namespace TDEDisplayPowerLevel { enum TDEDisplayPowerLevel { On, Standby, Suspend, Off }; }; class TDECORE_EXPORT TDEBacklightDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEBacklightDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEBacklightDevice(); /** * @return a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level */ TDEDisplayPowerLevel::TDEDisplayPowerLevel powerLevel(); /** * @return an integer with the number of discrete control steps available */ int brightnessSteps(); /** * @return a double with the current brightness percentage */ double brightnessPercent(); /** * @return TRUE if permissions allow brightness can be set, FALSE if not */ bool canSetBrightness(); /** * @return an int with the current raw brightness */ int rawBrightness(); /** * @param br an integer with the new raw brightness value */ void setRawBrightness(int br); protected: /** * @param pl a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level * @internal */ void internalSetPowerLevel(TDEDisplayPowerLevel::TDEDisplayPowerLevel pl); /** * @param br an integer with the maximum raw brightness value * @internal */ void internalSetMaximumRawBrightness(int br); /** * @param br an integer with the current raw brightness value * @internal */ void internalSetCurrentRawBrightness(int br); private: TDEDisplayPowerLevel::TDEDisplayPowerLevel m_powerLevel; int m_currentBrightness; int m_maximumBrightness; friend class TDEHardwareDevices; }; typedef TQPair TDEResolutionPair; typedef TQValueList< TDEResolutionPair > TDEResolutionList; class TDECORE_EXPORT TDEMonitorDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEMonitorDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEMonitorDevice(); /** * @return TRUE if a monitor is connected, FALSE if not */ bool connected(); /** * @return TRUE if this port is enabled, FALSE if not */ bool enabled(); /** * @return a TQByteArray containing this monitor's EDID information */ TQByteArray edid(); /** * @return a TDEResolutionList containing this monitor's supported resolutions */ TDEResolutionList resolutions(); /** * @return a TQString containing the display port type */ TQString portType(); /** * @return a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level */ TDEDisplayPowerLevel::TDEDisplayPowerLevel powerLevel(); protected: /** * @param TRUE if a monitor is connected, FALSE if not * @internal */ void internalSetConnected(bool cn); /** * @param TRUE if this port is enabled, FALSE if not * @internal */ void internalSetEnabled(bool en); /** * @param ed a TQByteArray containing this monitor's EDID information * @internal */ void internalSetEdid(TQByteArray ed); /** * @param rs a TDEResolutionList containing this monitor's supported resolutions * @internal */ void internalSetResolutions(TDEResolutionList rs); /** * @param pt a TQString containing the display port type * @internal */ void internalSetPortType(TQString pt); /** * @param pl a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level * @internal */ void internalSetPowerLevel(TDEDisplayPowerLevel::TDEDisplayPowerLevel pl); private: bool m_connected; bool m_enabled; TQByteArray m_edid; TDEResolutionList m_resolutions; TQString m_portType; TDEDisplayPowerLevel::TDEDisplayPowerLevel m_powerLevel; friend class TDEHardwareDevices; }; typedef TQMap TDESensorClusterMap; class TDECORE_EXPORT TDESensorDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDESensorDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDESensorDevice(); /** * @return a TDESensorClusterMap with the current sensor values */ TDESensorClusterMap values(); protected: /** * @param a TDESensorClusterMap with the current sensor values * @internal */ void internalSetValues(TDESensorClusterMap cl); private: TDESensorClusterMap m_sensorValues; friend class TDEHardwareDevices; }; namespace TDESystemFormFactor { enum TDESystemFormFactor { Unclassified, Desktop, Laptop, Server, Other = 0x80000000 }; }; namespace TDESystemPowerState { enum TDESystemPowerState { Active, Standby, Suspend, Hibernate, PowerOff, Reboot }; }; namespace TDESystemHibernationMethod { enum TDESystemHibernationMethod { Unsupported, Platform, Shutdown, Reboot, TestProc, Test }; }; typedef TQValueList TDESystemPowerStateList; typedef TQValueList TDESystemHibernationMethodList; class TDECORE_EXPORT TDERootSystemDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDERootSystemDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDERootSystemDevice(); /** * @return a TDESystemFormFactor::TDESystemFormFactor with the system's form factor */ TDESystemFormFactor::TDESystemFormFactor formFactor(); /** * @return a TDESystemPowerStateList with all available power states */ TDESystemPowerStateList powerStates(); /** * @return a TDESystemHibernationMethodList with all available hibernation methods */ TDESystemHibernationMethodList hibernationMethods(); /** * @return a TDESystemHibernationMethod::TDESystemHibernationMethod with the current hibernation method */ TDESystemHibernationMethod::TDESystemHibernationMethod hibernationMethod(); /** * @return an unsigned long with the number of bytes required to hibernate */ unsigned long diskSpaceNeededForHibernation(); /** * @return TRUE if permissions allow the hibernation method to be set, FALSE if not */ bool canSetHibernationMethod(); /** * @return TRUE if hardware and permissions allow the system to enter standby, FALSE if not */ bool canStandby(); /** * @return TRUE if hardware and permissions allow the system to be suspended, FALSE if not */ bool canSuspend(); /** * @return TRUE if hardware and permissions allow the system to be hibernated, FALSE if not */ bool canHibernate(); /** * @return TRUE if permissions allow the system to be powered down, FALSE if not */ bool canPowerOff(); /** * @return TRUE if permissions allow the system to be rebooted, FALSE if not */ bool canReboot(); /** * @param hm a TDESystemHibernationMethod::TDESystemHibernationMethod with the desired hibernation method */ void setHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm); /** * @param ps a TDESystemPowerState::TDESystemPowerState with the desired power state * @return TRUE if power state was set */ bool setPowerState(TDESystemPowerState::TDESystemPowerState ps); protected: /** * @param ff a TDESystemFormFactor::TDESystemFormFactor with the system's form factor * @internal */ void internalSetFormFactor(TDESystemFormFactor::TDESystemFormFactor ff); /** * @param ps a TDESystemPowerStateList with all available power states * @internal */ void internalSetPowerStates(TDESystemPowerStateList ps); /** * @param hm a TDESystemHibernationMethodList with all available hibernation methods * @internal */ void internalSetHibernationMethods(TDESystemHibernationMethodList hm); /** * @param hm a TDESystemHibernationMethod::TDESystemHibernationMethod with the current hibernation method * @internal */ void internalSetHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm); /** * @param sz an unsigned long with the number of bytes required to hibernate * @internal */ void internalSetDiskSpaceNeededForHibernation(unsigned long sz); private: TDESystemFormFactor::TDESystemFormFactor m_formFactor; TDESystemPowerStateList m_powerStates; TDESystemHibernationMethodList m_hibernationMethods; TDESystemHibernationMethod::TDESystemHibernationMethod m_hibernationMethod; unsigned long m_hibernationSpace; friend class TDEHardwareDevices; }; namespace TDEEventDeviceType { enum TDEEventDeviceType { Unknown, ACPILidSwitch, ACPISleepButton, ACPIPowerButton, Other = 0x80000000 }; }; // Keep friendlySwitchList() in tdehardwaredevices.cpp in sync with this enum namespace TDESwitchType { enum TDESwitchType { Null = 0x00000000, Lid = 0x00000001, TabletMode = 0x00000002, HeadphoneInsert = 0x00000004, RFKill = 0x00000008, Radio = 0x00000010, MicrophoneInsert = 0x00000020, Dock = 0x00000040, LineOutInsert = 0x00000080, JackPhysicalInsert = 0x00000100, VideoOutInsert = 0x00000200, CameraLensCover = 0x00000400, KeypadSlide = 0x00000800, FrontProximity = 0x00001000, RotateLock = 0x00002000, LineInInsert = 0x00004000 }; inline TDESwitchType operator|(TDESwitchType a, TDESwitchType b) { return static_cast(static_cast(a) | static_cast(b)); } inline TDESwitchType operator&(TDESwitchType a, TDESwitchType b) { return static_cast(static_cast(a) & static_cast(b)); } inline TDESwitchType operator~(TDESwitchType a) { return static_cast(~static_cast(a)); } }; class TQSocketNotifier; class TDECORE_EXPORT TDEEventDevice : public TDEGenericDevice { Q_OBJECT public: /** * Constructor. * @param Device type */ TDEEventDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEEventDevice(); /** * @return a TDEEventDeviceType::TDEEventDeviceType with the event device type, if known */ TDEEventDeviceType::TDEEventDeviceType eventType(); /** * @return a TDESwitchType::TDESwitchType with all switches provided by this device */ TDESwitchType::TDESwitchType providedSwitches(); /** * @return a TDESwitchType::TDESwitchType with all active switches provided by this device */ TDESwitchType::TDESwitchType activeSwitches(); /** * @param switches a TDESwitchType::TDESwitchType with any switch flags set * @return a TQStringList with friendly names for all set switch flags */ static TQStringList friendlySwitchList(TDESwitchType::TDESwitchType switches); protected: /** * @param et a TDEEventDeviceType::TDEEventDeviceType with the event device type, if known * @internal */ void internalSetEventType(TDEEventDeviceType::TDEEventDeviceType et); /** * @param sl a TDESwitchType::TDESwitchType with all switches provided by this device * @internal */ void internalSetProvidedSwitches(TDESwitchType::TDESwitchType sl); /** * @param sl a TDESwitchType::TDESwitchType with all active switches provided by this device * @internal */ void internalSetActiveSwitches(TDESwitchType::TDESwitchType sl); /** * @param hwmanager the master hardware manager * @internal */ void internalStartFdMonitoring(TDEHardwareDevices* hwmanager); protected slots: void eventReceived(); signals: /** * @param keycode the code of the key that was pressed/released * See include/linux/input.h for a complete list of keycodes * @param device a TDEEventDevice* with the device that received the event */ void keyPressed(unsigned int keycode, TDEEventDevice* device); private: TDEEventDeviceType::TDEEventDeviceType m_eventType; TDESwitchType::TDESwitchType m_providedSwitches; TDESwitchType::TDESwitchType m_switchActive; int m_fd; bool m_fdMonitorActive; TQSocketNotifier* m_eventNotifier; friend class TDEHardwareDevices; }; namespace TDEInputDeviceType { enum TDEInputDeviceType { Unknown, ACPILidSwitch, ACPISleepButton, ACPIPowerButton, Other = 0x80000000 }; }; class TDECORE_EXPORT TDEInputDevice : public TDEGenericDevice { public: /** * Constructor. * @param Device type */ TDEInputDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null); /** * Destructor. */ ~TDEInputDevice(); /** * @return a TDEInputDeviceType::TDEInputDeviceType with the input device type, if known */ TDEInputDeviceType::TDEInputDeviceType inputType(); protected: /** * @param it a TDEInputDeviceType::TDEInputDeviceType with the input device type, if known * @internal */ void internalSetInputType(TDEInputDeviceType::TDEInputDeviceType it); private: TDEInputDeviceType::TDEInputDeviceType m_inputType; friend class TDEHardwareDevices; }; typedef TQPtrList TDEGenericHardwareList; typedef TQMap TDEDeviceIDMap; class KSimpleDirWatch; class TDECORE_EXPORT TDEHardwareDevices : public TQObject { Q_OBJECT public: /** * Constructor. */ TDEHardwareDevices(); /** * Destructor. */ ~TDEHardwareDevices(); /** * Query all hardware capabilities on all devices * This does not normally need to be called by an application, as * device detection is handled internally and automatically * * A call to this method immediately invalidates any TDEGenericHardwareList * structures returned by listAllPhysicalDevices() * * @return TRUE if successful */ bool queryHardwareInformation(); /** * List all hardware capabilities on all devices * @return TDEGenericHardwareList containing all known hardware devices */ TDEGenericHardwareList listAllPhysicalDevices(); /** * List all hardware capabilities on all devices * @param a TDEGenericDeviceType::TDEGenericDeviceType specifying the device class * @return TDEGenericHardwareList containing all known hardware devices */ TDEGenericHardwareList listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl); /** * Return the device with system path @arg syspath, or 0 if no device exists for that path * @return TDEGenericDevice */ TDEGenericDevice* findBySystemPath(TQString syspath); /** * Return the device with unique ID @arg uid, or 0 if no device exists for that uid * @return TDEGenericDevice */ TDEGenericDevice* findByUniqueID(TQString uid); /** * Return the device with device node @arg devnode, or 0 if no device exists at that node * @return TDEGenericDevice */ TDEGenericDevice* findByDeviceNode(TQString devnode); /** * Return the storage device with unique ID @arg uid, or 0 if no device exists for that uid * @return TDEGenericDevice */ TDEStorageDevice* findDiskByUID(TQString uid); /** * Look up the device in the system PCI database * @param vendorid a TQString containing the vendor ID in hexadecimal * @param modelid a TQString containing the model ID in hexadecimal * @param subvendorid a TQString containing the subvendor ID in hexadecimal * @param submodelid a TQString containing the submodel ID in hexadecimal * @return a TQString containing the device name, if found */ TQString findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid); /** * Look up the device in the system USB database * @param vendorid a TQString containing the vendor ID in hexadecimal * @param modelid a TQString containing the model ID in hexadecimal * @param subvendorid a TQString containing the subvendor ID in hexadecimal * @param submodelid a TQString containing the submodel ID in hexadecimal * @return a TQString containing the device name, if found */ TQString findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid); /** * Look up the device in the system PNP database * @param pnpid a TQString containing the PNP ID * @return a TQString containing the device name, if found */ TQString findPNPDeviceName(TQString pnpid); /** * Look up the monitor manufacturer in the system display database * @param pnpid a TQString containing the display manufacturer ID * @return a TQString containing the manufacturer name, if found */ TQString findMonitorManufacturerName(TQString dpyid); /** * Get a friendly string describing a device type * @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type * @return a TQString containing the friendly type name */ TQString getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query); /** * Get an icon for a device type * @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type * @param size a TDEIcon::StdSizes structure specifying the desired icon size * @return a TQPixmap containing the icon for the specified type */ TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, TDEIcon::StdSizes size); /** * Convenience function to obtain the root system device * @return a pointer to a TDERootSystemDevice object */ TDERootSystemDevice* rootSystemDevice(); /** * Rescan a hardware device to look for changes * WARNING: This method can be very expensive. Use with caution! * @param hwdevice TDEGenericDevice* with the device to rescan */ void rescanDeviceInformation(TDEGenericDevice* hwdevice); /** * Rescan a hardware device to look for changes * WARNING: This method can be very expensive. Use with caution! * The computational expense can be reduced somewhat if the device tree structure * has not changed by calling this method with regenerateDeviceTree = FALSE. * @param hwdevice TDEGenericDevice* with the device to rescan * @param regenerateDeviceTree TRUE to update parent/child links in device tree */ void rescanDeviceInformation(TDEGenericDevice* hwdevice, bool regenerateDeviceTree); /** * Enable or disable automatic state updates of triggerless hardware devices * such as CPUs and network cards. When enabled, your application will use * additional CPU resources to continually poll triggerless hardware devices. * Automatic updates are disabled by default. * @param enable a bool specifiying whether or not automatic updates should be enabled */ void setTriggerlessHardwareUpdatesEnabled(bool enable); /** * Convert a byte count to human readable form * @param bytes a double containing the number of bytes * @return a TQString containing the human readable byte count */ static TQString bytesToFriendlySizeString(double bytes); signals: void hardwareAdded(TDEGenericDevice*); void hardwareRemoved(TDEGenericDevice*); void hardwareUpdated(TDEGenericDevice*); void mountTableModified(); void hardwareEvent(TDEHardwareEvent::TDEHardwareEvent, TQString uuid); /** * @param keycode the code of the key that was pressed/released * See include/linux/input.h for a complete list of keycodes * @param device a TDEEventDevice* with the device that received the event */ void eventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* device); private slots: void processHotPluggedHardware(); void processModifiedMounts(); void processModifiedCPUs(); void processStatelessDevices(); void processEventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* edevice); private: void updateBlacklists(TDEGenericDevice* hwdevice, udev_device* dev); private: TDEGenericDevice *classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice=0, bool force_full_classification=true); TDEGenericDevice *classifyUnknownDeviceByExternalRules(udev_device* dev, TDEGenericDevice* existingdevice=0, bool classifySubDevices=false); void updateExistingDeviceInformation(TDEGenericDevice* existingdevice, udev_device* dev=NULL); void updateParentDeviceInformation(); void updateParentDeviceInformation(TDEGenericDevice* hwdevice); void addCoreSystemDevices(); /** * Get the binary monitor EDID for the specified sysfs path * @return a TQByteArray containing the EDID */ TQByteArray getEDID(TQString path); /** * Get the monitor EDID name for the specified sysfs path * @return a TQPair containing the monitor vendor and model, if available */ TQPair getEDIDMonitorName(TQString path); struct udev *m_udevStruct; struct udev_monitor *m_udevMonitorStruct; TDEGenericHardwareList m_deviceList; int m_procMountsFd; KSimpleDirWatch* m_cpuWatch; TQTimer* m_cpuWatchTimer; TQTimer* m_deviceWatchTimer; TQSocketNotifier* m_devScanNotifier; TQSocketNotifier* m_mountScanNotifier; TQStringList m_mountTable; TQStringList m_cpuInfo; TDEDeviceIDMap* pci_id_map; TDEDeviceIDMap* usb_id_map; TDEDeviceIDMap* pnp_id_map; TDEDeviceIDMap* dpy_id_map; friend class TDEGenericDevice; friend class TDEStorageDevice; friend class TDECPUDevice; }; #endif // _TDEHARDWAREDEVICES_H