Error handling

Signed-off-by: Emanoil Kotsev <deloptes@gmail.com>

BrightnessService.cpp

@@ -42,10 +42,12 @@ BrightnessService::~BrightnessService()
 bool BrightnessService::CanSetBrightness(const TQString& device, bool& value, TQT_DBusError& error) {
 
     if (device.find( TQRegExp("^/sys/devices.*/brightness$"),0) == 0 ) {
-        value = canSetDeviceValue(device);
+        value = canSetDeviceValue(device, error);
     } else {
-        value = false;
         error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument for device: " + device));
+    }
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
         return false;
     }
     return true;
@@ -54,10 +56,12 @@ bool BrightnessService::CanSetBrightness(const TQString& device, bool& value, TQ
 bool BrightnessService::SetBrightness(const TQString& device, const TQString& brightness, bool& value, TQT_DBusError& error) {
 
     if (device.find( TQRegExp("^/sys/devices.*/brightness$"),0) == 0) {
-        value = setDeviceValue(device, brightness);
+        value = setDeviceValue(device, brightness, error);
     } else {
-        value = false;
         error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument for device: " + device));
+    }
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
         return false;
     }
     return true;

CPUGovernorService.cpp

@@ -41,10 +41,12 @@ bool CPUGovernorService::CanSetCPUGovernor(TQ_INT32 cpu, bool& value, TQT_DBusEr
     // do something
     TQString dev = TQString("/sys/devices/system/cpu/cpu%1/cpufreq/scaling_governor").arg(cpu);
     if ((cpu>-1)) {
-        value = canSetDeviceValue(dev);
+        value = canSetDeviceValue(dev, error);
     } else {
-        value = false;
-        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument cpu: %1, governor: %2").arg(dev).arg(cpu));
+        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument cpu: %1, governor: %2").arg(cpu).arg(dev));
+    }
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
         return false;
     }
     return true;
@@ -54,10 +56,12 @@ bool CPUGovernorService::SetCPUGovernor(TQ_INT32 cpu, const TQString& governor,
 
     TQString dev = TQString("/sys/devices/system/cpu/cpu%1/cpufreq/scaling_governor").arg(cpu);
     if ((cpu>-1) && !governor.isEmpty()) {
-        value = setDeviceValue(dev, governor);
+        value = setDeviceValue(dev, governor, error);
     } else {
-        value = false;
-        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument cpu: %1, governor: %2").arg(dev).arg(governor));
+        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument cpu: %1, governor: %2").arg(cpu).arg(governor));
+    }
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
         return false;
     }
     return true;

DeviceServiceBase.cpp

@@ -27,6 +27,8 @@
 #include <unistd.h>
 #include <stdio.h>
 
+#include <tqdbuserror.h>
+
 #include "DeviceServiceBase.h"
 
 DeviceServiceBase::DeviceServiceBase(TQT_DBusConnection &conn)
@@ -42,7 +44,7 @@ DeviceServiceBase::~DeviceServiceBase()
         delete m_connection;
 }
 
-bool DeviceServiceBase::canSetDeviceValue(const TQString& device) {
+bool DeviceServiceBase::canSetDeviceValue(const TQString& device, TQT_DBusError& error) {
     // check if path is writable
     int rval = access (device.latin1(), W_OK);
     if (rval != 0)
@@ -50,11 +52,11 @@ bool DeviceServiceBase::canSetDeviceValue(const TQString& device) {
     return true;
 }
 
-bool DeviceServiceBase::setDeviceValue(const TQString& device, const TQString& param) {
+bool DeviceServiceBase::setDeviceValue(const TQString& device, const TQString& param, TQT_DBusError& error) {
 
     bool written = false;
     // make sure path is writable
-    if (canSetDeviceValue(device)) {
+    if (canSetDeviceValue(device, error)) {
         FILE *node = fopen(device.latin1(), "w");
         if (node != NULL) {
             if (fputs(param.latin1(), node) != EOF) {
@@ -62,10 +64,11 @@ bool DeviceServiceBase::setDeviceValue(const TQString& device, const TQString& p
             }
             if (fclose(node) == EOF) {
                 // Error!
-                tqWarning(TQString("Device %1 not properly closed").arg(device).local8Bit().data());
+                error = TQT_DBusError::stdFailed(TQString ("Device %1 not properly closed").arg(device));
             }
+        } else {
+            error = TQT_DBusError::stdFailed(TQString ("Could not open device %1").arg(device));
         }
     }
-
     return written;
 }

DeviceServiceBase.h

@@ -32,8 +32,8 @@ public:
     virtual ~DeviceServiceBase();
 
 protected:
-    bool canSetDeviceValue(const TQString& device);
-    bool setDeviceValue(const TQString& device, const TQString& param);
+    bool canSetDeviceValue(const TQString& device, TQT_DBusError& error);
+    bool setDeviceValue(const TQString& device, const TQString& param, TQT_DBusError& error);
 
 protected:
     TQT_DBusConnection *m_connection;

InputEventsService.cpp

@@ -55,9 +55,10 @@ InputEventsService::~InputEventsService()
  *
  */
 
-bool InputEventsService::getSwitches(const TQString& device, TQValueList< TQ_UINT32 >& value, bool active) {
+TQValueList< TQ_UINT32 > InputEventsService::getSwitches(const TQString& device, bool active, TQT_DBusError& error) {
     int fd, r;
     unsigned long switches[NUM_BITS(EV_CNT)];
+    TQValueList< TQ_UINT32 > value = TQValueList< TQ_UINT32 >();
 
     if (!device.isEmpty() && (device.find("/dev/input/event") == 0) ) {
         fd = open(device.latin1(), O_RDONLY);
@@ -73,18 +74,33 @@ bool InputEventsService::getSwitches(const TQString& device, TQValueList< TQ_UIN
                 value.append( switches[i] );
             }
         }
+        else {
+            error = TQT_DBusError::stdFailed(TQString ("Failed to handle IOCTL for device: " + device));
+        }
         close(fd);
+    } else {
+        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument for device: " + device));
     }
 
-    return true;
+    return value;
 }
 
 bool InputEventsService::GetProvidedSwitches(const TQString& device, TQValueList< TQ_UINT32 >& value, TQT_DBusError& error) {
-    return getSwitches(device, value, false);
+    value = getSwitches(device, false, error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
+    return true;
 }
 
 bool InputEventsService::GetActiveSwitches(const TQString& device, TQValueList< TQ_UINT32 >& value, TQT_DBusError& error) {
-    return getSwitches(device, value, true);
+    value = getSwitches(device, true, error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
+    return true;
 }
 
 void InputEventsService::handleMethodReply(const TQT_DBusMessage& reply) {

InputEventsService.h

@@ -33,7 +33,7 @@ public:
     virtual ~InputEventsService();
 protected:
 
-    virtual bool getSwitches(const TQString& device, TQValueList< TQ_UINT32 >& value, bool active);
+    TQValueList< TQ_UINT32 > getSwitches(const TQString& device, bool active, TQT_DBusError& error);
 
     virtual bool GetProvidedSwitches(const TQString& device, TQValueList< TQ_UINT32 >& value, TQT_DBusError& error);
 

PowerService.cpp

@@ -42,7 +42,7 @@ PowerService::~PowerService()
     // TODO Auto-generated destructor stub
 }
 
-bool PowerService::canSetHibernation(TQString disk, TQString state) {
+bool PowerService::canSetHibernation(TQString disk, TQString state, TQT_DBusError& error) {
 
     // check if path is writable
     bool state_writable = false;
@@ -70,6 +70,7 @@ bool PowerService::canSetHibernation(TQString disk, TQString state) {
             }
             if (fclose(statenode) == EOF) {
                 // Error!
+                error = TQT_DBusError::stdInvalidArgs(TQString ("Could not flush stream for method " + method1));
             }
         }
         FILE *disknode = fopen("/sys/power/disk", "r");
@@ -83,6 +84,7 @@ bool PowerService::canSetHibernation(TQString disk, TQString state) {
             }
             if (fclose(disknode) == EOF) {
                 // Error!
+                error = TQT_DBusError::stdInvalidArgs(TQString ("Could not flush stream for method " + method2));
             }
         }
     }
@@ -91,7 +93,7 @@ bool PowerService::canSetHibernation(TQString disk, TQString state) {
     return state_writable && disk_writable && method1 && method2;
 }
 
-bool PowerService::setHibernation(TQString disk, TQString state) {
+bool PowerService::setHibernation(TQString disk, TQString state, TQT_DBusError& error) {
     // set hibernation state
 
     bool written1 = false, written2 = false;
@@ -116,6 +118,7 @@ bool PowerService::setHibernation(TQString disk, TQString state) {
             }
             if (fclose(disknode) == EOF) {
                 // Error!
+                error = TQT_DBusError::stdInvalidArgs(TQString ("Could not flush stream for method " + disk));
             }
         }
         if (written1)
@@ -127,6 +130,7 @@ bool PowerService::setHibernation(TQString disk, TQString state) {
                 }
                 if (fclose(statenode) == EOF) {
                     // Error!
+                    error = TQT_DBusError::stdInvalidArgs(TQString ("Could not flush stream for method " + state));
                 }
             }
         }
@@ -142,77 +146,121 @@ bool PowerService::setHibernation(TQString disk, TQString state) {
 
 bool PowerService::CanStandby(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetDeviceValue("/sys/power/state");
+    value = canSetDeviceValue("/sys/power/state", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::Standby(bool& value, TQT_DBusError& error) {
     // do something
-    value = setDeviceValue("/sys/power/state", "standby");
+    value = setDeviceValue("/sys/power/state", "standby", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::CanFreeze(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetDeviceValue("/sys/power/state") && canSetDeviceValue("/sys/power/disk");
+    value = canSetDeviceValue("/sys/power/state", error) && canSetDeviceValue("/sys/power/disk", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::Freeze(bool& value, TQT_DBusError& error) {
     // do something
-    value = setDeviceValue("/sys/power/disk", "freeze");
+    value = setDeviceValue("/sys/power/disk", "freeze", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::CanSuspend(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetDeviceValue("/sys/power/state") && canSetDeviceValue("/sys/power/disk");
-    return true;
+    value = canSetDeviceValue("/sys/power/state", error) && canSetDeviceValue("/sys/power/disk", error);
+    return (error.isValid()) ? false : true;
 }
 
 bool PowerService::Suspend(bool& value, TQT_DBusError& error) {
     // do something
-    value = setDeviceValue("/sys/power/state", "mem");
+    value = setDeviceValue("/sys/power/state", "mem", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::CanHibernate(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetHibernation(TQString("/sys/power/disk"), "platform");
+    value = canSetHibernation(TQString("/sys/power/disk"), "platform", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::Hibernate(bool& value, TQT_DBusError& error) {
     // do something
-    value = setHibernation("/sys/power/disk", "platform");
+    value = setHibernation("/sys/power/disk", "platform", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::CanHybridSuspend(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetHibernation("/sys/power/disk", "suspend");
+    value = canSetHibernation("/sys/power/disk", "suspend", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::HybridSuspend(bool& value, TQT_DBusError& error) {
     // do something
-    value = setHibernation("/sys/power/disk", "suspend");
+    value = setHibernation("/sys/power/disk", "suspend", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::CanSetHibernationMethod(bool& value, TQT_DBusError& error) {
     // do something
-    value = canSetDeviceValue("/sys/power/disk");
+    value = canSetDeviceValue("/sys/power/disk", error);
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
+        return false;
+    }
     return true;
 }
 
 bool PowerService::SetHibernationMethod(const TQString& method, bool& value, TQT_DBusError& error) {
     // set hibernation method
     if (!method.isEmpty()) {
-        value = setDeviceValue("/sys/power/disk", method);
+        value = setDeviceValue("/sys/power/disk", method, error);
     }
     else {
         //TODO may be set dbus error
+        error = TQT_DBusError::stdInvalidArgs(TQString ("Invalid argument for method: " + method));
+    }
+    if (error.isValid()) {
+        tqDebug(error.message().local8Bit().data());
         return false;
     }
     return true;

PowerService.h

@@ -32,9 +32,9 @@ public:
     PowerService(TQT_DBusConnection&);
     virtual ~PowerService();
 protected:
-    bool canSetHibernation(TQString disk, TQString state);
+    bool canSetHibernation(TQString disk, TQString state, TQT_DBusError& error);
 
-    bool setHibernation(TQString disk, TQString state);
+    bool setHibernation(TQString disk, TQString state, TQT_DBusError& error);
 
     virtual bool CanStandby(bool& value, TQT_DBusError& error);