tdehardwaredevices.h

/* This file is part of the TDE libraries
   Copyright (C) 2012-2014 Timothy Pearson <kb9vqf@pearsoncomputing.net>

   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 <tqobject.h>
#include <tqptrlist.h>
#include <tqmap.h>
#include <tqdict.h>
#include <tqstring.h>
#include <tqstringlist.h>

#include "tdelibs_export.h"
#include "kicontheme.h"

#include "tdehwcommontypes.h"

// FIXME delete those headers after complete fixing everything in over modules
#include "tdegenericdevice.h"
#include "kiconloader.h"
extern "C" {
#include <libudev.h>
}
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include "tdestoragedevice.h"
#include "tdecpudevice.h"
#include "tdebatterydevice.h"
#include "tdemainspowerdevice.h"
#include "tdenetworkdevice.h"
#include "tdebacklightdevice.h"
#include "tdemonitordevice.h"
#include "tdesensordevice.h"
#include "tderootsystemdevice.h"
#include "tdeeventdevice.h"
#include "tdeinputdevice.h"
#include "tdecryptographiccarddevice.h"

struct udev_device;

class KSimpleDirWatch;

class TDEGenericDevice;
class TDEStorageDevice;
class TDENetworkDevice;
class TDEBacklightDevice;
class TDEMonitorDevice;
class TDESensorDevice;
class TDERootSystemDevice;
class TDEEventDevice;
class TDEInputDevice;
class TQSocketNotifier;

typedef TQPtrList<TDEGenericDevice> TDEGenericHardwareList;
typedef TQMap<TQString, TQString> TDEDeviceIDMap;
typedef TQDict<TDECPUDevice> TDECPUDeviceCache;

class TDECORE_EXPORT TDEHardwareDevices : public TQObject
{
    Q_OBJECT

    public: 
        TDEHardwareDevices();
        
        ~TDEHardwareDevices();

        bool queryHardwareInformation();

        TDEGenericHardwareList listAllPhysicalDevices();

        TDEGenericHardwareList listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl);

        TDEGenericDevice* findBySystemPath(TQString syspath);

        TDEGenericDevice* findByUniqueID(TQString uid);

        TDEGenericDevice* findByDeviceNode(TQString devnode);

        TDEStorageDevice* findDiskByUID(TQString uid);

        TDECPUDevice* findCPUBySystemPath(TQString syspath, bool inCache);
            
        TQString findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);

        TQString findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);

        TQString findPNPDeviceName(TQString pnpid);

        TQString findMonitorManufacturerName(TQString dpyid);

        TQString getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query);

        TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, TDEIcon::StdSizes size);

        TDERootSystemDevice* rootSystemDevice();

        void rescanDeviceInformation(TDEGenericDevice* hwdevice);

        void rescanDeviceInformation(TDEGenericDevice* hwdevice, bool regenerateDeviceTree);

        void setTriggerlessHardwareUpdatesEnabled(bool enable);

        void setBatteryUpdatesEnabled(bool enable);
        
        static TQString bytesToFriendlySizeString(double bytes);

    signals:
        void hardwareAdded(TDEGenericDevice*);
        void hardwareRemoved(TDEGenericDevice*);
        void hardwareUpdated(TDEGenericDevice*);
        void mountTableModified();
        void hardwareEvent(TDEHardwareEvent::TDEHardwareEvent, TQString uuid);

        void eventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* device);

    private slots:
        void processHotPluggedHardware();
        void processModifiedMounts();
        void processModifiedCPUs();
        void processBatteryDevices();
        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();

        TQByteArray getEDID(TQString path);
        
        TQPair<TQString,TQString> 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_batteryWatchTimer;
        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;
        
        TDECPUDeviceCache m_cpuByPathCache;

    friend class TDEGenericDevice;
    friend class TDEStorageDevice;
    friend class TDECPUDevice;
};

#endif // _TDEHARDWAREDEVICES_H