Get uptime from sys/sysinfo.h instead of parsing uptime output. Fixes #2

harbour-sailtime.pro

@@ -10,10 +10,14 @@ TARGET = harbour-sailtime
 
 CONFIG += sailfishapp
 
-HEADERS += src/uptimechecker.h
+HEADERS += src/uptimechecker.h \
+    src/sysinfoc.h \
+    src/sysload.h
 
 SOURCES += src/harbour-sailtime.cpp \
-    src/uptimechecker.cpp
+    src/uptimechecker.cpp \
+    src/sysinfoc.cpp \
+    src/sysload.cpp
 
 OTHER_FILES += qml/harbour-sailtime.qml \
     qml/cover/CoverPage.qml \

qml/harbour-sailtime.qml

@@ -6,7 +6,9 @@
 
 import QtQuick 2.0
 import Sailfish.Silica 1.0
-import harbour.sailtime.UptimeChecker 1.0
+import harbour.sailtime.UptimeChecker 2.0
+import harbour.sailtime.SysinfoC 1.0
+import harbour.sailtime.Sysload 1.0
 import "cover"
 import "pages"
 
@@ -61,36 +63,21 @@ ApplicationWindow
     }
 
     function updateDisplay() {
-        var uptime_str = checker.fetchUptime();
+        var sysinfo = checker.fetchUptime();
-        uptime_str = uptime_str.replace(/^\s+|\s+$/g, '');
+        var uptime_s = sysinfo.uptime;
 
-        var uptime_re = /\d+:\d\d:\d\d up\s+(?:(\d+) days?,\s+)?(?:(?:(\d+):(\d+))|(?:(\d?\d) min)),\s+(\d+) users?,\s+load average: (\d+).(\d\d), (\d+).(\d\d), (\d+).(\d\d)/;
+        var days = Math.floor(uptime_s / 84600);
-        var match = uptime_str.match(uptime_re)
+        var hours = Math.floor(uptime_s / 3600 % 24);
-        //console.log(uptime_str)
+        var minutes = Math.floor(uptime_s / 60 % 60);
-
+        var seconds = Math.floor(uptime_s % 60);
-        var days = match[1]
-        if (days === undefined) {
-            days = 0
-        }
-
-        var hours = match[2]
-        if (hours === undefined) {
-            hours = 0
-        }
-
-        var minutes = match[3]
-        if (minutes === undefined) {
-            minutes = match[4]
-        }
 
         var uptime = {
             "days": days,
             "hours": hours,
             "minutes": minutes,
-            "users": match[5],
+            "load1": sysinfo.loads.avg_1,
-            "load1": parseInt(match[6]) + match[7] / 100,
+            "load5": sysinfo.loads.avg_5,
-            "load5": parseInt(match[8]) + match[9] / 100,
+            "load15": sysinfo.loads.avg_15,
-            "load15": parseInt(match[10]) + match[11] / 100,
         }
 
         firstpage.updatePage(uptime);

qml/pages/AboutPage.qml

@@ -29,7 +29,7 @@ Page {
 
             Label {
                 anchors.horizontalCenter: parent.horizontalCenter
-                text: "SailTime 1.0.2"
+                text: "SailTime 1.1.0"
                 color: Theme.highlightColor
                 font.pixelSize: Theme.fontSizeLarge
             }

rpm/harbour-sailtime.spec

@@ -13,7 +13,7 @@ Name:       harbour-sailtime
 %{!?qtc_make:%define qtc_make make}
 %{?qtc_builddir:%define _builddir %qtc_builddir}
 Summary:    SailTime
-Version:    1.0.2
+Version:    1.1.0
 Release:    1
 Group:      Qt/Qt
 License:    MIT Expat licence

rpm/harbour-sailtime.yaml

@@ -1,6 +1,6 @@
 Name: harbour-sailtime
 Summary: SailTime
-Version: 1.0.2
+Version: 1.1.0
 Release: 1
 Group: Qt/Qt
 URL: http://example.org/

src/harbour-sailtime.cpp

@@ -5,10 +5,13 @@
  */
 
 #include <QtQuick>
+#include <QtQml>
 
 #include <sailfishapp.h>
 
 #include "uptimechecker.h"
+#include "sysinfoc.h"
+#include "sysload.h"
 
 
 int main(int argc, char *argv[])
@@ -22,7 +25,11 @@ int main(int argc, char *argv[])
     //
     // To display the view, call "show()" (will show fullscreen on device).
 
-    qmlRegisterType<UptimeChecker>("harbour.sailtime.UptimeChecker", 1, 0, "UptimeChecker");
+    // Register needed metatypes
+    qmlRegisterType<UptimeChecker>("harbour.sailtime.UptimeChecker", 2, 0, "UptimeChecker");
+    qmlRegisterUncreatableType<SysinfoC>("harbour.sailtime.SysinfoC", 1, 0, "SysinfoC", "Cannot create sysinfo");
+    qmlRegisterUncreatableType<Sysload>("harbour.sailtime.Sysload", 1, 0, "Sysload", "Cannot create sysload");
+
     return SailfishApp::main(argc, argv);
 }
 

src/sysinfoc.cpp

@@ -0,0 +1,90 @@
+#include "sysinfoc.h"
+#include <linux/kernel.h>
+
+SysinfoC::SysinfoC(const struct sysinfo* info, QObject* parent) :
+    QObject(parent),
+    uptime(info->uptime),
+    totalram(info->totalram),
+    freeram(info->freeram),
+    sharedram(info->sharedram),
+    bufferram(info->bufferram),
+    totalswap(info->totalswap),
+    freeswap(info->freeswap),
+    procs(info->procs),
+    totalhigh(info->totalhigh),
+    freehigh(info->freehigh),
+    mem_unit(info->mem_unit)
+{
+    float in_loads[3] = {0.0, 0.0, 0.0};
+    in_loads[0] = load2Float(info->loads[0]);
+    in_loads[1] = load2Float(info->loads[1]);
+    in_loads[2] = load2Float(info->loads[2]);
+
+    this->loads = new Sysload(in_loads, this);
+}
+
+float SysinfoC::load2Float(unsigned long load)
+{
+    // As per http://stackoverflow.com/a/4993273
+    return load / ((float) (1 << SI_LOAD_SHIFT));
+}
+
+long SysinfoC::getUptime() const
+{
+    return uptime;
+}
+
+Sysload* SysinfoC::getLoads() const
+{
+    return loads;
+}
+
+unsigned long SysinfoC::getTotalram() const
+{
+    return totalram;
+}
+
+unsigned long SysinfoC::getFreeram() const
+{
+    return freeram;
+}
+
+unsigned long SysinfoC::getSharedram() const
+{
+    return sharedram;
+}
+
+unsigned long SysinfoC::getBufferram() const
+{
+    return bufferram;
+}
+
+unsigned long SysinfoC::getTotalswap() const
+{
+    return totalswap;
+}
+
+unsigned long SysinfoC::getFreeswap() const
+{
+    return freeswap;
+}
+
+unsigned short SysinfoC::getProcs() const
+{
+    return procs;
+}
+
+unsigned long SysinfoC::getTotalhigh() const
+{
+    return totalhigh;
+}
+
+unsigned long SysinfoC::getFreehigh() const
+{
+    return freehigh;
+}
+
+unsigned int SysinfoC::getMemunit() const
+{
+    return mem_unit;
+}

src/sysinfoc.h

@@ -0,0 +1,70 @@
+#ifndef SYSINFO_H
+#define SYSINFO_H
+
+#include <QObject>
+#include <sys/sysinfo.h>
+
+#include "sysload.h"
+
+/*
+ * This class exists because we cannot pass plain structs onto the QML side,
+ * we need to inherit from QObject.
+ */
+class SysinfoC : public QObject
+{
+    Q_OBJECT
+public:
+    explicit SysinfoC(const struct sysinfo* info, QObject* parent = 0);
+
+    /*
+     * Loads are reported as unsigned longs in the sysinfo struct, this function
+     * will convert them to floats which are usually used for displaying loads.
+     */
+    static float load2Float(unsigned long load);
+
+    Q_PROPERTY(long uptime READ getUptime)
+    Q_PROPERTY(Sysload* loads READ getLoads)
+    Q_PROPERTY(unsigned long totalram READ getTotalram)
+    Q_PROPERTY(unsigned long freeram READ getFreeram)
+    Q_PROPERTY(unsigned long sharedram READ getSharedram)
+    Q_PROPERTY(unsigned long bufferram READ getBufferram)
+    Q_PROPERTY(unsigned long totalswap READ getTotalswap)
+    Q_PROPERTY(unsigned long freeswap READ getFreeswap)
+    Q_PROPERTY(unsigned short procs READ getProcs)
+    Q_PROPERTY(unsigned long totalhigh READ getTotalhigh)
+    Q_PROPERTY(unsigned long freehigh READ getFreehigh)
+    Q_PROPERTY(unsigned int mem_unit READ getMemunit)
+
+    long getUptime() const;
+    Sysload* getLoads() const;
+    unsigned long getTotalram() const;
+    unsigned long getFreeram() const;
+    unsigned long getSharedram() const;
+    unsigned long getBufferram() const;
+    unsigned long getTotalswap() const;
+    unsigned long getFreeswap() const;
+    unsigned short getProcs() const;
+    unsigned long getTotalhigh() const;
+    unsigned long getFreehigh() const;
+    unsigned int getMemunit() const;
+
+signals:
+
+public slots:
+
+private:
+    long uptime;                  /* Seconds since boot */
+    Sysload* loads;               /* 1, 5, and 15 minute load averages */
+    unsigned long totalram;       /* Total usable main memory size */
+    unsigned long freeram;        /* Available memory size */
+    unsigned long sharedram;      /* Amount of shared memory */
+    unsigned long bufferram;      /* Memory used by buffers */
+    unsigned long totalswap;      /* Total swap space size */
+    unsigned long freeswap;       /* swap space still available */
+    unsigned short procs;         /* Number of current processes */
+    unsigned long totalhigh;      /* Total high memory size */
+    unsigned long freehigh;       /* Available high memory size */
+    unsigned int mem_unit;        /* Memory unit size in bytes */
+};
+
+#endif // SYSINFO_H

src/sysload.cpp

@@ -0,0 +1,24 @@
+#include "sysload.h"
+
+Sysload::Sysload(float loads[3], QObject *parent) :
+    QObject(parent),
+    avg_1(loads[0]),
+    avg_5(loads[1]),
+    avg_15(loads[2])
+{
+}
+
+float Sysload::getAvg1() const
+{
+    return avg_1;
+}
+
+float Sysload::getAvg5() const
+{
+    return avg_5;
+}
+
+float Sysload::getAvg15() const
+{
+    return avg_15;
+}

src/sysload.h

@@ -0,0 +1,33 @@
+#ifndef SYSLOAD_H
+#define SYSLOAD_H
+
+#include <QObject>
+#include <sys/sysinfo.h>
+
+class Sysload : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Sysload(float loads[3], QObject* parent = 0);
+
+    Q_PROPERTY(float avg_1 READ getAvg1)
+    Q_PROPERTY(float avg_5 READ getAvg5)
+    Q_PROPERTY(float avg_15 READ getAvg15)
+
+    float getAvg1() const;
+    float getAvg5() const;
+    float getAvg15() const;
+
+signals:
+
+public slots:
+
+private:
+    float avg_1;
+    float avg_5;
+    float avg_15;
+
+
+};
+
+#endif // SYSLOAD_H

src/uptimechecker.cpp

@@ -11,11 +11,9 @@ UptimeChecker::UptimeChecker(QObject *parent) :
     QObject(parent)
 {}
 
-QString UptimeChecker::fetchUptime()
+SysinfoC* UptimeChecker::fetchUptime()
 {
-    QProcess process;
+    struct sysinfo info;
-    process.start("uptime");
+    sysinfo(&info);
-    process.waitForFinished(-1);
+    return new SysinfoC(&info, this);
-    QByteArray out = process.readAllStandardOutput();
-    return QString(out);
 }

src/uptimechecker.h

@@ -8,8 +8,8 @@
 #define UPTIMECHECKER_H
 
 #include <QObject>
-#include <QByteArray>
+#include "sys/sysinfo.h"
-#include <QProcess>
+#include "sysinfoc.h"
 
 class UptimeChecker : public QObject
 {
@@ -17,7 +17,7 @@ class UptimeChecker : public QObject
 public:
     explicit UptimeChecker(QObject *parent = 0);
 
-    Q_INVOKABLE QString fetchUptime();
+    Q_INVOKABLE SysinfoC* fetchUptime();
 };
 
 #endif // UPTIMECHECKER_H