From 05be3d4e9145560968c3afc78c1fcca644cc7a9e Mon Sep 17 00:00:00 2001 From: Developer Date: Wed, 27 Jul 2011 18:16:38 +0200 Subject: [PATCH] LatitudeUpdater 0.1, fix the previous commit --- LatitudeUpdater-common.pri | 53 +++ LatitudeUpdater-daemon.pro | 7 + LatitudeUpdater-qml.pro | 10 + LatitudeUpdater-widget.pro | 7 + LatitudeUpdater.pro | 4 + LatitudeUpdaterDaemon.desktop | 11 + LatitudeUpdaterDaemon.png | Bin 0 -> 3646 bytes LatitudeUpdaterQML.desktop | 11 + LatitudeUpdaterQML.png | Bin 0 -> 3646 bytes LatitudeUpdaterWidget.desktop | 11 + LatitudeUpdaterWidget.png | Bin 0 -> 3646 bytes deployment.pri | 114 ++++++ googlelatitude.cpp | 180 +++++++++ googlelatitude.h | 57 +++ gpscontrol.cpp | 127 +++++++ gpscontrol.h | 49 +++ latitudedaemon.cpp | 17 + latitudedaemon.h | 54 +++ latitudeqml.cpp | 15 + latitudeqml.h | 25 ++ latitudewidget.cpp | 136 +++++++ latitudewidget.h | 142 +++++++ libkqoauth/QtKOAuth | 5 + libkqoauth/kqoauthauthreplyserver.cpp | 104 ++++++ libkqoauth/kqoauthauthreplyserver.h | 47 +++ libkqoauth/kqoauthauthreplyserver_p.h | 47 +++ libkqoauth/kqoauthglobals.h | 44 +++ libkqoauth/kqoauthmanager.cpp | 492 +++++++++++++++++++++++++ libkqoauth/kqoauthmanager.h | 177 +++++++++ libkqoauth/kqoauthmanager_p.h | 71 ++++ libkqoauth/kqoauthrequest.cpp | 589 ++++++++++++++++++++++++++++++ libkqoauth/kqoauthrequest.h | 145 ++++++++ libkqoauth/kqoauthrequest_1.cpp | 5 + libkqoauth/kqoauthrequest_1.h | 12 + libkqoauth/kqoauthrequest_p.h | 93 +++++ libkqoauth/kqoauthrequest_xauth.cpp | 89 +++++ libkqoauth/kqoauthrequest_xauth.h | 49 +++ libkqoauth/kqoauthrequest_xauth_p.h | 14 + libkqoauth/kqoauthutils.cpp | 79 ++++ libkqoauth/kqoauthutils.h | 33 ++ main-daemon.cpp | 16 + main-qml.cpp | 15 + main-widget.cpp | 15 + not_used/glupdater | 13 + not_used/gpsmaemo5.cpp | 110 ++++++ not_used/gpsmaemo5.h | 63 ++++ qml/MainPage.qml | 238 ++++++++++++ qml/main.qml | 12 + qtc_packaging/debian_fremantle/README | 10 + qtc_packaging/debian_fremantle/changelog | 5 + qtc_packaging/debian_fremantle/compat | 1 + qtc_packaging/debian_fremantle/control | 20 + qtc_packaging/debian_fremantle/copyright | 34 ++ qtc_packaging/debian_fremantle/rules | 91 +++++ qtc_packaging/debian_harmattan/README | 10 + qtc_packaging/debian_harmattan/changelog | 5 + qtc_packaging/debian_harmattan/compat | 1 + qtc_packaging/debian_harmattan/control | 20 + qtc_packaging/debian_harmattan/copyright | 34 ++ qtc_packaging/debian_harmattan/rules | 91 +++++ resouses.qrc | 6 + 61 files changed, 3935 insertions(+) create mode 100644 LatitudeUpdater-common.pri create mode 100644 LatitudeUpdater-daemon.pro create mode 100644 LatitudeUpdater-qml.pro create mode 100644 LatitudeUpdater-widget.pro create mode 100644 LatitudeUpdater.pro create mode 100644 LatitudeUpdaterDaemon.desktop create mode 100644 LatitudeUpdaterDaemon.png create mode 100644 LatitudeUpdaterQML.desktop create mode 100644 LatitudeUpdaterQML.png create mode 100644 LatitudeUpdaterWidget.desktop create mode 100644 LatitudeUpdaterWidget.png create mode 100644 deployment.pri create mode 100644 googlelatitude.cpp create mode 100644 googlelatitude.h create mode 100644 gpscontrol.cpp create mode 100644 gpscontrol.h create mode 100644 latitudedaemon.cpp create mode 100644 latitudedaemon.h create mode 100644 latitudeqml.cpp create mode 100644 latitudeqml.h create mode 100644 latitudewidget.cpp create mode 100644 latitudewidget.h create mode 100644 libkqoauth/QtKOAuth create mode 100644 libkqoauth/kqoauthauthreplyserver.cpp create mode 100644 libkqoauth/kqoauthauthreplyserver.h create mode 100644 libkqoauth/kqoauthauthreplyserver_p.h create mode 100644 libkqoauth/kqoauthglobals.h create mode 100644 libkqoauth/kqoauthmanager.cpp create mode 100644 libkqoauth/kqoauthmanager.h create mode 100644 libkqoauth/kqoauthmanager_p.h create mode 100644 libkqoauth/kqoauthrequest.cpp create mode 100644 libkqoauth/kqoauthrequest.h create mode 100644 libkqoauth/kqoauthrequest_1.cpp create mode 100644 libkqoauth/kqoauthrequest_1.h create mode 100644 libkqoauth/kqoauthrequest_p.h create mode 100644 libkqoauth/kqoauthrequest_xauth.cpp create mode 100644 libkqoauth/kqoauthrequest_xauth.h create mode 100644 libkqoauth/kqoauthrequest_xauth_p.h create mode 100644 libkqoauth/kqoauthutils.cpp create mode 100644 libkqoauth/kqoauthutils.h create mode 100644 main-daemon.cpp create mode 100644 main-qml.cpp create mode 100644 main-widget.cpp create mode 100644 not_used/glupdater create mode 100644 not_used/gpsmaemo5.cpp create mode 100644 not_used/gpsmaemo5.h create mode 100644 qml/MainPage.qml create mode 100644 qml/main.qml create mode 100644 qtc_packaging/debian_fremantle/README create mode 100644 qtc_packaging/debian_fremantle/changelog create mode 100644 qtc_packaging/debian_fremantle/compat create mode 100644 qtc_packaging/debian_fremantle/control create mode 100644 qtc_packaging/debian_fremantle/copyright create mode 100755 qtc_packaging/debian_fremantle/rules create mode 100644 qtc_packaging/debian_harmattan/README create mode 100644 qtc_packaging/debian_harmattan/changelog create mode 100644 qtc_packaging/debian_harmattan/compat create mode 100644 qtc_packaging/debian_harmattan/control create mode 100644 qtc_packaging/debian_harmattan/copyright create mode 100755 qtc_packaging/debian_harmattan/rules create mode 100644 resouses.qrc diff --git a/LatitudeUpdater-common.pri b/LatitudeUpdater-common.pri new file mode 100644 index 0000000..08adb36 --- /dev/null +++ b/LatitudeUpdater-common.pri @@ -0,0 +1,53 @@ +QT += network +CONFIG += mobility +MOBILITY += location + +SOURCES += gpscontrol.cpp googlelatitude.cpp +HEADERS += gpscontrol.h googlelatitude.h + +contains(QT_CONFIG, maemo5) { + QT += maemo5 + CONFIG += link_pkgconfig + PKGCONFIG += glib-2.0 liblocation +} + +INCLUDEPATH += libkqoauth +SOURCES += libkqoauth/kqoauthauthreplyserver.cpp \ +libkqoauth/kqoauthrequest.cpp \ +libkqoauth/kqoauthmanager.cpp \ +libkqoauth/kqoauthrequest_xauth.cpp \ +libkqoauth/kqoauthrequest_1.cpp \ +libkqoauth/kqoauthutils.cpp + +PUBLIC_HEADERS += libkqoauth/kqoauthmanager.h \ +libkqoauth/kqoauthrequest.h \ +libkqoauth/kqoauthrequest_1.h \ +libkqoauth/kqoauthrequest_xauth.h \ +libkqoauth/kqoauthglobals.h + +PRIVATE_HEADERS += libkqoauth/kqoauthrequest_p.h \ +libkqoauth/kqoauthmanager_p.h \ +libkqoauth/kqoauthauthreplyserver.h \ +libkqoauth/kqoauthauthreplyserver_p.h \ +libkqoauth/kqoauthutils.h \ +libkqoauth/kqoauthrequest_xauth_p.h + +HEADERS += $$PUBLIC_HEADERS $$PRIVATE_HEADERS + +# Please do not modify the following two lines. Required for deployment. +include(deployment.pri) +qtcAddDeployment() + +OTHER_FILES += \ + qtc_packaging/debian_harmattan/rules \ + qtc_packaging/debian_harmattan/README \ + qtc_packaging/debian_harmattan/copyright \ + qtc_packaging/debian_harmattan/control \ + qtc_packaging/debian_harmattan/compat \ + qtc_packaging/debian_harmattan/changelog \ + qtc_packaging/debian_fremantle/rules \ + qtc_packaging/debian_fremantle/README \ + qtc_packaging/debian_fremantle/copyright \ + qtc_packaging/debian_fremantle/control \ + qtc_packaging/debian_fremantle/compat \ + qtc_packaging/debian_fremantle/changelog diff --git a/LatitudeUpdater-daemon.pro b/LatitudeUpdater-daemon.pro new file mode 100644 index 0000000..3550b2a --- /dev/null +++ b/LatitudeUpdater-daemon.pro @@ -0,0 +1,7 @@ +TARGET = LatitudeUpdaterDaemon +QT -= gui + +SOURCES += latitudedaemon.cpp main-daemon.cpp +HEADERS += latitudedaemon.h + +include(LatitudeUpdater-common.pri) diff --git a/LatitudeUpdater-qml.pro b/LatitudeUpdater-qml.pro new file mode 100644 index 0000000..02e624e --- /dev/null +++ b/LatitudeUpdater-qml.pro @@ -0,0 +1,10 @@ +TARGET = LatitudeUpdaterQML +QT += declarative + +SOURCES += latitudeqml.cpp main-qml.cpp +HEADERS += latitudeqml.h + +RESOURCES += resouses.qrc +OTHER_FILES += qml/main.qml qml/MainPage.qml + +include(LatitudeUpdater-common.pri) diff --git a/LatitudeUpdater-widget.pro b/LatitudeUpdater-widget.pro new file mode 100644 index 0000000..129419c --- /dev/null +++ b/LatitudeUpdater-widget.pro @@ -0,0 +1,7 @@ +TARGET = LatitudeUpdaterWidget + +SOURCES += latitudewidget.cpp main-widget.cpp +HEADERS += latitudewidget.h + +include(LatitudeUpdater-common.pri) + diff --git a/LatitudeUpdater.pro b/LatitudeUpdater.pro new file mode 100644 index 0000000..e104265 --- /dev/null +++ b/LatitudeUpdater.pro @@ -0,0 +1,4 @@ +TEMPLATE = subdirs +SUBDIRS += LatitudeUpdater-daemon.pro +SUBDIRS += LatitudeUpdater-qml.pro +SUBDIRS += LatitudeUpdater-widget.pro diff --git a/LatitudeUpdaterDaemon.desktop b/LatitudeUpdaterDaemon.desktop new file mode 100644 index 0000000..901b786 --- /dev/null +++ b/LatitudeUpdaterDaemon.desktop @@ -0,0 +1,11 @@ +[Desktop Entry] +Encoding=UTF-8 +Version=1.0 +Type=Application +Terminal=true +Name=LatitudeDaemon +Exec=/opt/LatitudeUpdaterDaemon/bin/LatitudeUpdaterDaemon +Icon=LatitudeUpdaterDaDaemon +X-Window-Icon= +X-HildonDesk-ShowInToolbar=true +X-Osso-Type=application/x-executable diff --git a/LatitudeUpdaterDaemon.png b/LatitudeUpdaterDaemon.png new file mode 100644 index 0000000000000000000000000000000000000000..d98268f31e1c847a9b0e0d3fda477d7079f494d9 GIT binary patch literal 3646 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 Qv;Y7A07*qoM6N<$f^%-)0RR91 literal 0 HcmV?d00001 diff --git a/LatitudeUpdaterQML.desktop b/LatitudeUpdaterQML.desktop new file mode 100644 index 0000000..5b1a295 --- /dev/null +++ b/LatitudeUpdaterQML.desktop @@ -0,0 +1,11 @@ +[Desktop Entry] +Encoding=UTF-8 +Version=1.0 +Type=Application +Terminal=false +Name=LatitudeQML +Exec=/opt/LatitudeUpdaterQML/bin/LatitudeUpdaterQML +Icon=LatitudeUpdaterQML +X-Window-Icon= +X-HildonDesk-ShowInToolbar=true +X-Osso-Type=application/x-executable diff --git a/LatitudeUpdaterQML.png b/LatitudeUpdaterQML.png new file mode 100644 index 0000000000000000000000000000000000000000..d98268f31e1c847a9b0e0d3fda477d7079f494d9 GIT binary patch literal 3646 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 Qv;Y7A07*qoM6N<$f^%-)0RR91 literal 0 HcmV?d00001 diff --git a/LatitudeUpdaterWidget.desktop b/LatitudeUpdaterWidget.desktop new file mode 100644 index 0000000..85e2deb --- /dev/null +++ b/LatitudeUpdaterWidget.desktop @@ -0,0 +1,11 @@ +[Desktop Entry] +Encoding=UTF-8 +Version=1.0 +Type=Application +Terminal=false +Name=LatitudeWidget +Exec=/opt/LatitudeUpdaterWidget/bin/LatitudeUpdaterWidget +Icon=LatitudeUpdaterWidget +X-Window-Icon= +X-HildonDesk-ShowInToolbar=true +X-Osso-Type=application/x-executable diff --git a/LatitudeUpdaterWidget.png b/LatitudeUpdaterWidget.png new file mode 100644 index 0000000000000000000000000000000000000000..d98268f31e1c847a9b0e0d3fda477d7079f494d9 GIT binary patch literal 3646 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 Qv;Y7A07*qoM6N<$f^%-)0RR91 literal 0 HcmV?d00001 diff --git a/deployment.pri b/deployment.pri new file mode 100644 index 0000000..f147e99 --- /dev/null +++ b/deployment.pri @@ -0,0 +1,114 @@ +# This file was generated by an application wizard of Qt Creator. +# The code below handles deployment to Symbian and Maemo, aswell as copying +# of the application data to shadow build directories on desktop. +# It is recommended not to modify this file, since newer versions of Qt Creator +# may offer an updated version of it. + +defineTest(qtcAddDeployment) { +for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + itemsources = $${item}.sources + $$itemsources = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath= $$eval($${deploymentfolder}.target) + export($$itemsources) + export($$itempath) + DEPLOYMENT += $$item +} + +MAINPROFILEPWD = $$PWD + +symbian { + isEmpty(ICON):exists($${TARGET}.svg):ICON = $${TARGET}.svg + isEmpty(TARGET.EPOCHEAPSIZE):TARGET.EPOCHEAPSIZE = 0x20000 0x2000000 +} else:win32 { + copyCommand = + for(deploymentfolder, DEPLOYMENTFOLDERS) { + source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source) + source = $$replace(source, /, \\) + sourcePathSegments = $$split(source, \\) + target = $$OUT_PWD/$$eval($${deploymentfolder}.target)/$$last(sourcePathSegments) + target = $$replace(target, /, \\) + !isEqual(source,$$target) { + !isEmpty(copyCommand):copyCommand += && + isEqual(QMAKE_DIR_SEP, \\) { + copyCommand += $(COPY_DIR) \"$$source\" \"$$target\" + } else { + source = $$replace(source, \\\\, /) + target = $$OUT_PWD/$$eval($${deploymentfolder}.target) + target = $$replace(target, \\\\, /) + copyCommand += test -d \"$$target\" || mkdir -p \"$$target\" && cp -r \"$$source\" \"$$target\" + } + } + } + !isEmpty(copyCommand) { + copyCommand = @echo Copying application data... && $$copyCommand + copydeploymentfolders.commands = $$copyCommand + first.depends = $(first) copydeploymentfolders + export(first.depends) + export(copydeploymentfolders.commands) + QMAKE_EXTRA_TARGETS += first copydeploymentfolders + } +} else:unix { + maemo5 { + desktopfile.path = /usr/share/applications/hildon + } else { + desktopfile.path = /usr/share/applications + copyCommand = + for(deploymentfolder, DEPLOYMENTFOLDERS) { + source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source) + source = $$replace(source, \\\\, /) + macx { + target = $$OUT_PWD/$${TARGET}.app/Contents/Resources/$$eval($${deploymentfolder}.target) + } else { + target = $$OUT_PWD/$$eval($${deploymentfolder}.target) + } + target = $$replace(target, \\\\, /) + sourcePathSegments = $$split(source, /) + targetFullPath = $$target/$$last(sourcePathSegments) + !isEqual(source,$$targetFullPath) { + !isEmpty(copyCommand):copyCommand += && + copyCommand += $(MKDIR) \"$$target\" + copyCommand += && $(COPY_DIR) \"$$source\" \"$$target\" + } + } + !isEmpty(copyCommand) { + copyCommand = @echo Copying application data... && $$copyCommand + copydeploymentfolders.commands = $$copyCommand + first.depends = $(first) copydeploymentfolders + export(first.depends) + export(copydeploymentfolders.commands) + QMAKE_EXTRA_TARGETS += first copydeploymentfolders + } + } + installPrefix = /opt/$${TARGET} + for(deploymentfolder, DEPLOYMENTFOLDERS) { + item = item$${deploymentfolder} + itemfiles = $${item}.files + $$itemfiles = $$eval($${deploymentfolder}.source) + itempath = $${item}.path + $$itempath = $${installPrefix}/$$eval($${deploymentfolder}.target) + export($$itemfiles) + export($$itempath) + INSTALLS += $$item + } + icon.files = $${TARGET}.png + icon.path = /usr/share/icons/hicolor/64x64/apps + desktopfile.files = $${TARGET}.desktop + target.path = $${installPrefix}/bin + export(icon.files) + export(icon.path) + export(desktopfile.files) + export(desktopfile.path) + export(target.path) + INSTALLS += desktopfile icon target +} + +export (ICON) +export (INSTALLS) +export (DEPLOYMENT) +export (TARGET.EPOCHEAPSIZE) +export (TARGET.CAPABILITY) +export (LIBS) +export (QMAKE_EXTRA_TARGETS) +} diff --git a/googlelatitude.cpp b/googlelatitude.cpp new file mode 100644 index 0000000..81b1d5b --- /dev/null +++ b/googlelatitude.cpp @@ -0,0 +1,180 @@ +#include "googlelatitude.h" +#include + +GoogleLatitude::GoogleLatitude(QObject *parent) : + QObject(parent), + OauthSettings(this), + OAuthGetRequestToken("https://www.google.com/accounts/OAuthGetRequestToken"), + OAuthAuthorizeToken("https://www.google.com/accounts/OAuthAuthorizeToken"), + OAuthGetAccessToken("https://www.google.com/accounts/OAuthGetAccessToken"), + CurrentLocation("https://www.googleapis.com/latitude/v1/currentLocation"), + UserAuthorization(""), + ConsumerKey("1062862865804.apps.googleusercontent.com"), + ConsumerSecretKey("EYQaRaUJ9Fznw8mPMor660Kx"), + CurrentLatitude(0), + CurrentLongitude(0), + CurrentAccuracy(0) { + qDebug() << "* GoogleLatitude::GoogleLatitude"; + OauthRequest = new KQOAuthRequest(this); + OauthManager = new KQOAuthManager(this); + GoogleOauthAdditional.insert("scope", "https://www.googleapis.com/auth/latitude"); + GoogleOauthAdditional.insert("xoauth_displayname", "LatitudeUpdater"); + + connect(OauthManager, SIGNAL(temporaryTokenReceived(QString,QString)), + this, SLOT(onTemporaryTokenReceived(QString, QString))); + + connect(OauthManager, SIGNAL(authorizationReceived(QString,QString)), + this, SLOT(onAuthorizationReceived(QString, QString))); + + connect(OauthManager, SIGNAL(accessTokenReceived(QString,QString)), + this, SLOT(onAccessTokenReceived(QString,QString))); + + connect(OauthManager, SIGNAL(requestReady(QByteArray)), + this, SLOT(onRequestReady(QByteArray))); + + connect(OauthManager, SIGNAL(authorizedRequestDone()), + this, SLOT(onAuthorizedRequestDone())); + + connect(this, SIGNAL(gotToken()), + this, SLOT(getCurrentLocation())); + + connect(this, SIGNAL(notToken()), + this, SLOT(onNotToken())); + + connect(this, SIGNAL(gotToken()), + this, SLOT(onGotToken())); + + connect(this, SIGNAL(needAuth()), + this, SLOT(onNeedAuth())); +} + +GoogleLatitude::~GoogleLatitude() { + qDebug() << "* GoogleLatitude::~GoogleLatitude"; + delete OauthManager; + delete OauthRequest; +} + +void GoogleLatitude::getAccess() { + qDebug() << "* GoogleLatitude::getAccess"; + if ( OauthSettings.value("oauth_token").isNull() || OauthSettings.value("oauth_token_secret").isNull() ) { + OauthRequest->clearRequest(); + OauthRequest->initRequest(KQOAuthRequest::TemporaryCredentials, OAuthGetRequestToken); + OauthRequest->setConsumerKey(ConsumerKey); + OauthRequest->setConsumerSecretKey(ConsumerSecretKey); + OauthRequest->setAdditionalParameters(GoogleOauthAdditional); + OauthManager->setHandleUserAuthorization(true); + OauthRequest->setHttpMethod(KQOAuthRequest::POST); + OauthManager->executeRequest(OauthRequest); + } else { + emit gotToken(); + } +} + +void GoogleLatitude::getCurrentLocation() { + qDebug() << "* GoogleLatitude::getCurrentLocation"; + if ( OauthSettings.value("oauth_token").isNull() || OauthSettings.value("oauth_token_secret").isNull() ) { + emit notToken(); + } else { + OauthRequest->clearRequest(); + OauthRequest->initRequest(KQOAuthRequest::AuthorizedRequest, CurrentLocation); + OauthRequest->setToken(OauthSettings.value("oauth_token").toString()); + OauthRequest->setTokenSecret(OauthSettings.value("oauth_token_secret").toString()); + OauthRequest->setConsumerKey(ConsumerKey); + OauthRequest->setConsumerSecretKey(ConsumerSecretKey); + OauthRequest->setHttpMethod(KQOAuthRequest::GET); + OauthManager->executeRequest(OauthRequest); + } +} + +void GoogleLatitude::sendCurrentLocation() { + qDebug() << "* GoogleLatitude::sendCurrentLocation"; + if (OauthSettings.value("oauth_token").isNull() || OauthSettings.value("oauth_token_secret").isNull()) { + emit notToken(); + } else { + if (abs(CurrentLatitude) <= 0.01) return; + if (abs(CurrentLongitude) <= 0.01) return; + if (abs(CurrentAccuracy) <= 0.01) return; + + if (!OauthSettings.value("net_auto").toBool()) { + QNetworkConfigurationManager mgr; + if (!mgr.isOnline()) { + qDebug() << "* GoogleLatitude::sendCurrentLocation" << "offline"; + return; + } + } + + QByteArray json_location; + json_location = "{\"data\": {\"kind\":\"latitude#location\","; + json_location += QString("\"latitude\":%1,").arg(CurrentLatitude); + json_location += QString("\"longitude\":%1,").arg(CurrentLongitude); + json_location += QString("\"accuracy\":%1").arg(CurrentAccuracy); + json_location += "}}"; + qDebug() << "json_location" << json_location; + + OauthRequest->clearRequest(); + OauthRequest->initRequest(KQOAuthRequest::AuthorizedRequest, CurrentLocation); + OauthRequest->setToken(OauthSettings.value("oauth_token").toString()); + OauthRequest->setTokenSecret(OauthSettings.value("oauth_token_secret").toString()); + OauthRequest->setConsumerKey(ConsumerKey); + OauthRequest->setConsumerSecretKey(ConsumerSecretKey); + OauthRequest->setHttpMethod(KQOAuthRequest::POST); + OauthRequest->setContentType("application/json"); + OauthRequest->setRawData(json_location); + OauthManager->executeRequest(OauthRequest); + } +} + +void GoogleLatitude::setCurrentLocation(double lat, double lon, double acc) { + qDebug() << "* GoogleLatitude::setCurrentLocation" << lat << lon << acc; + CurrentLatitude = lat; + CurrentLongitude = lon; + CurrentAccuracy = acc; +} + +QUrl GoogleLatitude::getUserAuthorization() { + qDebug() << "* GoogleLatitude::getUserAuthorization"; + return UserAuthorization; +} + +void GoogleLatitude::setAutoConnect(bool status) { + qDebug() << "* GoogleLatitude::setAutoConnect" << status; + OauthSettings.setValue("net_auto", status); +} + +bool GoogleLatitude::getAutoConnect() { + qDebug() << "* GoogleLatitude::getAutoConnect"; + return OauthSettings.value("net_auto").toBool(); +} + +void GoogleLatitude::onTemporaryTokenReceived(QString temporaryToken, QString temporaryTokenSecret) { + qDebug() << "* GoogleLatitude::onTemporaryTokenReceived" << temporaryToken << temporaryTokenSecret; + if( OauthManager->lastError() == KQOAuthManager::NoError) { + UserAuthorization = OauthManager->getUserAuthorization(OAuthAuthorizeToken); + qDebug() << "* GoogleLatitude::onTemporaryTokenReceived" << "UserAuthorization" << UserAuthorization; + emit needAuth(); + } +} + +void GoogleLatitude::onAuthorizationReceived(QString token, QString verifier) { + qDebug() << "* GoogleLatitude::onAuthorizationReceived" << token << verifier; + OauthManager->getUserAccessTokens(OAuthGetAccessToken); + if(OauthManager->lastError() != KQOAuthManager::NoError) { + emit notToken(); + } +} + +void GoogleLatitude::onAccessTokenReceived(QString token, QString tokenSecret) { + qDebug() << "* GoogleLatitude::onAccessTokenReceived" << token << tokenSecret; + OauthSettings.setValue("oauth_token", token); + OauthSettings.setValue("oauth_token_secret", tokenSecret); + emit gotToken(); +} + +void GoogleLatitude::onRequestReady(QByteArray response) { + qDebug() << "* GoogleLatitude::onRequestReady" << response; + if (response.contains("Invalid Credentials") ) { + OauthSettings.remove("oauth_token"); + OauthSettings.remove("oauth_token_secret"); + emit notToken(); + } +} diff --git a/googlelatitude.h b/googlelatitude.h new file mode 100644 index 0000000..1f99a24 --- /dev/null +++ b/googlelatitude.h @@ -0,0 +1,57 @@ +#ifndef GOOGLELATITUDE_H +#define GOOGLELATITUDE_H + +#include +#include +#include +#include + +class GoogleLatitude : public QObject { + Q_OBJECT + +public: + GoogleLatitude(QObject *parent = 0); + ~GoogleLatitude(); + +public slots: + void getAccess(); + void getCurrentLocation(); + void sendCurrentLocation(); + void setCurrentLocation(double la, double lo, double ac); + QUrl getUserAuthorization(); + void setAutoConnect(bool status); + bool getAutoConnect(); + +private slots: + void onTemporaryTokenReceived(QString temporaryToken, QString temporaryTokenSecret); + void onAuthorizationReceived(QString token, QString verifier); + void onAccessTokenReceived(QString token, QString tokenSecret); + void onRequestReady(QByteArray response); + void onAuthorizedRequestDone() { qDebug() << "* GoogleLatitude::onAuthorizedRequestDone"; } + void onNotToken() { qDebug() << "* GoogleLatitude::onNotToken"; } + void onGotToken() { qDebug() << "* GoogleLatitude::onGotToken"; } + void onNeedAuth() { qDebug() << "* GoogleLatitude::onNeedAuth"; } + +signals: + void notToken(); + void gotToken(); + void needAuth(); + +private: + QSettings OauthSettings; + QUrl OAuthGetRequestToken; + QUrl OAuthAuthorizeToken; + QUrl OAuthGetAccessToken; + QUrl CurrentLocation; + QUrl UserAuthorization; + KQOAuthParameters GoogleOauthAdditional; + QString ConsumerKey; + QString ConsumerSecretKey; + double CurrentLatitude; + double CurrentLongitude; + double CurrentAccuracy; + KQOAuthManager *OauthManager; + KQOAuthRequest *OauthRequest; +}; + +#endif // GOOGLELATITUDE_H diff --git a/gpscontrol.cpp b/gpscontrol.cpp new file mode 100644 index 0000000..8df1cc1 --- /dev/null +++ b/gpscontrol.cpp @@ -0,0 +1,127 @@ +#include "gpscontrol.h" +#include + +GpsControl::GpsControl(QObject *parent) : + QObject(parent), + GpsSettings(this), + GpsSource(QGeoPositionInfoSource::createDefaultSource(this)), + GpsPosition(), + GpsTimeout(this), + GpsInterval(this) { + qDebug() << "* GpsControl::GpsControl"; + + GpsTimeout.setSingleShot(true); + GpsInterval.setSingleShot(true); + + setPositioningMethod(GpsSettings.value("gps_method", "cell").toString()); + setTimeOut(GpsSettings.value("gps_timeout", 60).toInt()); + setInterval(GpsSettings.value("gps_interval", 15*60).toInt()); + + if (!GpsSource) qDebug() << "* GpsControl::GpsControl" << "Not GpsSource"; + + connect(GpsSource, SIGNAL(positionUpdated(QGeoPositionInfo)), + this, SLOT(setCurrentLocation(QGeoPositionInfo))); + + connect(this, SIGNAL(gotUpdate()), + this, SLOT(onGotUpdate())); + + connect(this, SIGNAL(gotFix()), + this, SLOT(onGotFix())); + +} + +void GpsControl::setTimeOut(int sec) { + qDebug() << "* GpsControl::setTimeOut" << sec; + GpsSettings.setValue("gps_timeout", sec); +} + +int GpsControl::getTimeOut() { + qDebug() << "* GpsControl::getTimeOut"; + return GpsSettings.value("gps_timeout").toInt(); +} + +void GpsControl::setInterval(int sec) { + qDebug() << "* GpsControl::setInterval" << sec; + GpsSettings.setValue("gps_interval", sec); +} + +int GpsControl::getInterval() { + qDebug() << "* GpsControl::getInterval"; + return GpsSettings.value("gps_interval").toInt(); +} + +void GpsControl::setPositioningMethod(QString method) { + qDebug() << "* GpsControl::setPositioningMethod" << method; + if (method == "gps") { + GpsSettings.setValue("gps_method", method); + if (GpsSource) GpsSource->setPreferredPositioningMethods(QGeoPositionInfoSource::SatellitePositioningMethods); + } + if (method == "cell") { + GpsSettings.setValue("gps_method", method); + if (GpsSource) GpsSource->setPreferredPositioningMethods(QGeoPositionInfoSource::NonSatellitePositioningMethods); + } + if (method == "all") { + GpsSettings.setValue("gps_method", method); + if (GpsSource) GpsSource->setPreferredPositioningMethods(QGeoPositionInfoSource::AllPositioningMethods); + } +} + +void GpsControl::startUpdates() { + qDebug() << "* GpsControl::start"; + if (!GpsSettings.value("net_auto").toBool()) { + QNetworkConfigurationManager mgr; + if (!mgr.isOnline()) { + qDebug() << "* GpsControl::start" << "offline"; + return; + } + } + + if (!GpsSource) return; + + GpsTimeout.singleShot(GpsSettings.value("gps_timeout").toInt()*1000, this, SLOT(stopUpdates())); + GpsInterval.singleShot(GpsSettings.value("gps_interval").toInt()*1000, this, SLOT(startUpdates())); + GpsSource->startUpdates(); +} + +void GpsControl::stopUpdates(bool force) { + qDebug() << "* GpsControl::stopUpdates" << force; + if (!GpsSource) return; + GpsSource->stopUpdates(); + + if (force) { + GpsTimeout.stop(); + GpsInterval.stop(); + } else { + if (GpsSource->lastKnownPosition(GpsSettings.value("gps_method") == "gps"?true:false).isValid() ) { + emit gotFix(); + } + } +} + +double GpsControl::getCurrentLatitude() { + qDebug() << "* GpsControl::getCurrentLatitude"; + return GpsPosition.coordinate().latitude(); +} + +double GpsControl::getCurrentLongitude() { + qDebug() << "* GpsControl::getCurrentLongitude"; + return GpsPosition.coordinate().longitude(); +} + +double GpsControl::getCurrentAccuracy() { + qDebug() << "* GpsControl::getCurrentAccuracy"; + return GpsPosition.attribute(QGeoPositionInfo::HorizontalAccuracy); +} + +unsigned int GpsControl::getCurrentTimestamp() { + qDebug() << "* GpsControl::getCurrentTimestamp"; + return GpsPosition.timestamp().toTime_t(); +} + +void GpsControl::setCurrentLocation(QGeoPositionInfo pos) { + qDebug() << "* GpsControl::setCurrentLocation" << pos; + if (pos.isValid()) { + GpsPosition = pos; + emit gotUpdate(); + } +} diff --git a/gpscontrol.h b/gpscontrol.h new file mode 100644 index 0000000..7a7f6f5 --- /dev/null +++ b/gpscontrol.h @@ -0,0 +1,49 @@ +#ifndef GPSCONTROL_H +#define GPSCONTROL_H + +#include +#include +#include +#include +#include +#include + +using namespace QtMobility; + +class GpsControl : public QObject { + Q_OBJECT +public: + GpsControl(QObject *parent = 0); + +signals: + void gotUpdate(); + void gotFix(); + +public slots: + void setTimeOut(int sec); + int getTimeOut(); + void setInterval(int sec); + int getInterval(); + void setPositioningMethod(QString method); + QString getPositioningMethod() {return GpsSettings.value("gps_method").toString();} + void startUpdates(); + void stopUpdates(bool force = false); + double getCurrentLatitude(); + double getCurrentLongitude(); + double getCurrentAccuracy(); + unsigned int getCurrentTimestamp(); + +private slots: + void setCurrentLocation(QGeoPositionInfo pos); + void onGotUpdate() { qDebug() << "* GpsControl::ongotUpdate"; } + void onGotFix() { qDebug() << "* GpsControl::ongotFix"; } + +private: + QSettings GpsSettings; + QGeoPositionInfoSource *GpsSource; + QGeoPositionInfo GpsPosition; + QTimer GpsTimeout; + QTimer GpsInterval; +}; + +#endif // GPSCONTROL_H diff --git a/latitudedaemon.cpp b/latitudedaemon.cpp new file mode 100644 index 0000000..35a31e6 --- /dev/null +++ b/latitudedaemon.cpp @@ -0,0 +1,17 @@ +#include "latitudedaemon.h" + +LatitudeDaemon::LatitudeDaemon(QObject *parent) : + QObject(parent), + latitude(this), + gps(this) { + qDebug() << "* LatitudeDaemon::LatitudeDaemon"; + + connect(&latitude, SIGNAL(gotToken()), this, SLOT(gl_GotToken()) ); + connect(&latitude, SIGNAL(notToken()), this, SLOT(gl_NotToken()) ); + connect(&latitude, SIGNAL(needAuth()), this, SLOT(gl_needAuth()) ); + + connect(&gps, SIGNAL(gotUpdate()), this, SLOT(get_gps()) ); + connect(&gps, SIGNAL(gotFix()), this, SLOT(set_latitude()) ); + + latitude.getAccess(); +} diff --git a/latitudedaemon.h b/latitudedaemon.h new file mode 100644 index 0000000..d18a673 --- /dev/null +++ b/latitudedaemon.h @@ -0,0 +1,54 @@ +#ifndef LATITUDEDAEMON_H +#define LATITUDEDAEMON_H + +#include +#include +#include "googlelatitude.h" +#include "gpscontrol.h" + +class LatitudeDaemon : public QObject { + Q_OBJECT +public: + LatitudeDaemon(QObject *parent = 0); +signals: + +public slots: + +private slots: + void gl_GotToken() { + qDebug() << "LatitudeDaemon::gl_GotToken()"; + gps.startUpdates(); + } + void gl_NotToken() { + qDebug() << "LatitudeDaemon::gl_NotToken()"; + QCoreApplication::exit(); + } + void gl_needAuth() { + qDebug() << "LatitudeDaemon::gl_needAuth()"; + QCoreApplication::exit(); + } + void get_gps() { + qDebug() << "LatitudeDaemon::get_gps()" + << gps.getCurrentLatitude() + << gps.getCurrentLongitude() + << gps.getCurrentAccuracy() + << gps.getCurrentTimestamp(); + } + void set_latitude() { + qDebug() << "LatitudeDaemon::set_latitude()" + << gps.getCurrentLatitude() + << gps.getCurrentLongitude() + << gps.getCurrentAccuracy() + << gps.getCurrentTimestamp(); + latitude.setCurrentLocation(gps.getCurrentLatitude(), + gps.getCurrentLongitude(), + gps.getCurrentAccuracy()); + latitude.sendCurrentLocation(); + } + +private: + GoogleLatitude latitude; + GpsControl gps; +}; + +#endif // LATITUDEDAEMON_H diff --git a/latitudeqml.cpp b/latitudeqml.cpp new file mode 100644 index 0000000..0dd7af1 --- /dev/null +++ b/latitudeqml.cpp @@ -0,0 +1,15 @@ +#include "latitudeqml.h" +#include + +LatitudeQML::LatitudeQML(QDeclarativeView *parent) : + QDeclarativeView(parent), + latitude(this), + gps(this) { + qDebug() << "* LatitudeQML::LatitudeQML"; + + rootContext()->setContextProperty("latitude", &latitude); + rootContext()->setContextProperty("gps", &gps); + setSource(QUrl("qrc:/qml/main.qml")); + + latitude.getAccess(); +} diff --git a/latitudeqml.h b/latitudeqml.h new file mode 100644 index 0000000..13c8b27 --- /dev/null +++ b/latitudeqml.h @@ -0,0 +1,25 @@ +#ifndef LatitudeQML_H +#define LatitudeQML_H + +#include +#include +#include "googlelatitude.h" +#include "gpscontrol.h" + +class LatitudeQML : public QDeclarativeView { + Q_OBJECT +public: + LatitudeQML(QDeclarativeView *parent = 0); + +signals: + +public slots: + +private slots: + +private: + GoogleLatitude latitude; + GpsControl gps; +}; + +#endif // LatitudeQML_H diff --git a/latitudewidget.cpp b/latitudewidget.cpp new file mode 100644 index 0000000..f81b786 --- /dev/null +++ b/latitudewidget.cpp @@ -0,0 +1,136 @@ +#include "latitudewidget.h" + +LatitudeGUI::LatitudeGUI(QWidget *parent) : + QWidget(parent), + latitude(this), + gps(this) { + qDebug() << "* LatitudeGUI::LatitudeGUI"; + setWindowTitle(tr("LatitudeUpdater")); + + // row 1 + layout_row1 = new QHBoxLayout(); + do_oauth = new QPushButton("Auth"); + do_start = new QPushButton("Start"); + do_stop = new QPushButton("Stop"); + layout_row1->addWidget(do_oauth); + layout_row1->addWidget(do_start); + layout_row1->addWidget(do_stop); + + do_oauth->setDisabled(true); + do_start->setDisabled(true); + do_stop->setDisabled(true); + + connect(do_oauth, SIGNAL(clicked()), this, SLOT(gl_webauth()) ); + connect(do_start, SIGNAL(clicked()), this, SLOT(gps_start()) ); + connect(do_stop, SIGNAL(clicked()), this, SLOT(gps_stop()) ); + + connect(&latitude, SIGNAL(gotToken()), this, SLOT(gl_GotToken()) ); + connect(&latitude, SIGNAL(notToken()), this, SLOT(gl_NotToken()) ); + connect(&latitude, SIGNAL(needAuth()), this, SLOT(gl_needAuth()) ); + + latitude.getAccess(); + + // row 2 + layout_row2 = new QHBoxLayout(); + pos_label = new QLabel("Position"); + pos_lat = new QLineEdit("lat"); + pos_lon = new QLineEdit("lon"); + pos_acc = new QLineEdit("acc"); + pos_tis = new QLineEdit("tis"); + + pos_lat->setReadOnly(true); + pos_lon->setReadOnly(true); + pos_acc->setReadOnly(true); + pos_tis->setReadOnly(true); + + layout_row2->addWidget(pos_label); + layout_row2->addWidget(pos_lat); + layout_row2->addWidget(pos_lon); + layout_row2->addWidget(pos_acc); + layout_row2->addWidget(pos_tis); + + connect(&gps, SIGNAL(gotUpdate()), this, SLOT(get_gps()) ); + connect(&gps, SIGNAL(gotFix()), this, SLOT(set_latitude()) ); + + // row 3 + layout_row3 = new QHBoxLayout(); + gps_group = new QButtonGroup(); + gps_method = new QLabel("Method"); + gps_cell = new QRadioButton("Cell Tower"); + gps_both = new QRadioButton("Both"); + gps_agps = new QRadioButton("Only Gps"); + gps_group->addButton(gps_cell); + gps_group->addButton(gps_both); + gps_group->addButton(gps_agps); + layout_row3->addWidget(gps_method); + layout_row3->addWidget(gps_cell); + layout_row3->addWidget(gps_both); + layout_row3->addWidget(gps_agps); + + if ( gps.getPositioningMethod() == "gps" ) gps_agps->setChecked(true); + if ( gps.getPositioningMethod() == "cell" ) gps_cell->setChecked(true); + if ( gps.getPositioningMethod() == "all" ) gps_both->setChecked(true); + + connect(gps_cell, SIGNAL(clicked()), this, SLOT(set_method()) ); + connect(gps_both, SIGNAL(clicked()), this, SLOT(set_method()) ); + connect(gps_agps, SIGNAL(clicked()), this, SLOT(set_method()) ); + + // row 4 + layout_row4 = new QHBoxLayout(); + gps_to_label = new QLabel("Time Out"); + gps_to_slider = new QSlider(Qt::Horizontal); + gps_to_slider->setSingleStep(5); + gps_to_slider->setRange(5, 120); + gps_to_slider->setValue(gps.getTimeOut()); + gps_to_slider_value = new QLabel(QString("%1 sec.").arg(gps_to_slider->value())); + layout_row4->addWidget(gps_to_label); + layout_row4->addWidget(gps_to_slider); + layout_row4->addWidget(gps_to_slider_value); + + connect(gps_to_slider, SIGNAL(valueChanged(int)), this, SLOT(set_to(int)) ); + + // row 5 + layout_row5 = new QHBoxLayout(); + gps_i_label = new QLabel("Interval"); + + gps_i_slider = new QSlider(Qt::Horizontal); + gps_i_slider->setSingleStep(5); + gps_i_slider->setRange(5, 60); + gps_i_slider->setValue(gps.getInterval()/60); + gps_i_slider_value = new QLabel(QString("%1 min.").arg(gps_i_slider->value())); + layout_row5->addWidget(gps_i_label); + layout_row5->addWidget(gps_i_slider); + layout_row5->addWidget(gps_i_slider_value); + + connect(gps_i_slider, SIGNAL(valueChanged(int)), this, SLOT(set_i(int)) ); + + // row 6 + layout_row6 = new QHBoxLayout(); + gps_ac_group = new QButtonGroup(); + gps_ac_label = new QLabel("Auto Connect"); + gps_ac_yes = new QRadioButton("Yes"); + gps_ac_not = new QRadioButton("No"); + gps_ac_group->addButton(gps_ac_yes); + gps_ac_group->addButton(gps_ac_not); + layout_row6->addWidget(gps_ac_label); + layout_row6->addWidget(gps_ac_yes); + layout_row6->addWidget(gps_ac_not); + + if ( latitude.getAutoConnect() == true ) gps_ac_yes->setChecked(true); + if ( latitude.getAutoConnect() == false ) gps_ac_not->setChecked(true); + + connect(gps_ac_yes, SIGNAL(clicked()), this, SLOT(set_ac_yes()) ); + connect(gps_ac_not, SIGNAL(clicked()), this, SLOT(set_ac_not()) ); + + // gui + layout_gui = new QVBoxLayout(); + layout_gui->addLayout(layout_row1); + layout_gui->addLayout(layout_row2); + layout_gui->addLayout(layout_row3); + layout_gui->addLayout(layout_row4); + layout_gui->addLayout(layout_row5); + layout_gui->addLayout(layout_row6); + + setLayout(layout_gui); +} + diff --git a/latitudewidget.h b/latitudewidget.h new file mode 100644 index 0000000..26bb749 --- /dev/null +++ b/latitudewidget.h @@ -0,0 +1,142 @@ +#ifndef LATITUDEGUI_H +#define LATITUDEGUI_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "googlelatitude.h" +#include "gpscontrol.h" + +class LatitudeGUI : public QWidget { + Q_OBJECT +public: + LatitudeGUI(QWidget *parent = 0); + +signals: + +public slots: + +private slots: + void gl_GotToken() { + qDebug() << "LatitudeGUI::gl_GotToken"; + do_oauth->setDisabled(true); + do_start->setEnabled(true); + do_stop->setDisabled(true); + } + void gl_NotToken() { + qDebug() << "LatitudeGUI::gl_NotToken"; + do_oauth->setEnabled(true); + do_start->setDisabled(true); + do_stop->setDisabled(true); + gps.stopUpdates(true); + } + void gl_needAuth() { + qDebug() << "LatitudeGUI::gl_needAuth"; + do_oauth->setEnabled(true); + } + void gl_webauth() { + qDebug() << "LatitudeGUI::gl_webauth"; + QDesktopServices::openUrl(latitude.getUserAuthorization()); + } + void gps_start() { + qDebug() << "LatitudeGUI::gps_start"; + do_start->setDisabled(true); + do_stop->setEnabled(true); + gps.startUpdates(); + } + void gps_stop() { + qDebug() << "LatitudeGUI::gps_stop"; + do_start->setEnabled(true); + do_stop->setDisabled(true); + gps.stopUpdates(true); + } + void get_gps() { + qDebug() << "LatitudeGUI::get_gps"; + pos_lat->setText(QString("%1").arg(gps.getCurrentLatitude())); + pos_lon->setText(QString("%1").arg(gps.getCurrentLongitude())); + pos_acc->setText(QString("%1").arg(gps.getCurrentAccuracy())); + pos_tis->setText(QString("%1").arg(gps.getCurrentTimestamp())); + } + void set_latitude() { + qDebug() << "LatitudeGUI::set_latitude"; + latitude.setCurrentLocation(pos_lat->text().toDouble(), + pos_lon->text().toDouble(), + pos_acc->text().toDouble()); + latitude.sendCurrentLocation(); + } + void set_method() { + qDebug() << "LatitudeGUI::set_method"; + if (gps_cell->isChecked()) gps.setPositioningMethod("cell"); + if (gps_both->isChecked()) gps.setPositioningMethod("all"); + if (gps_agps->isChecked()) gps.setPositioningMethod("gps"); + } + void set_to(int value) { + qDebug() << "LatitudeGUI::set_to()" << value; + gps.setTimeOut(value); + gps_to_slider_value->setText(QString("%1 sec.").arg(value)); + + } + void set_i(int value) { + qDebug() << "LatitudeGUI::set_i()" << value; + gps.setInterval(value*60); + gps_i_slider_value->setText(QString("%1 min.").arg(value)); + } + void set_ac_yes() { + qDebug() << "LatitudeGUI::set_ac_yes"; + latitude.setAutoConnect(true); + } + void set_ac_not() { + qDebug() << "LatitudeGUI::set_ac_not"; + latitude.setAutoConnect(false); + } + +private: + GoogleLatitude latitude; + GpsControl gps; + + QHBoxLayout *layout_row1; + QPushButton *do_oauth; + QPushButton *do_start; + QPushButton *do_stop; + + QHBoxLayout *layout_row2; + QLabel *pos_label; + QLineEdit *pos_lat; + QLineEdit *pos_lon; + QLineEdit *pos_acc; + QLineEdit *pos_tis; + + QHBoxLayout *layout_row3; + QLabel *gps_method; + QButtonGroup *gps_group; + QRadioButton *gps_cell; + QRadioButton *gps_both; + QRadioButton *gps_agps; + + QHBoxLayout *layout_row4; + QLabel *gps_to_label; + QSlider *gps_to_slider; + QLabel *gps_to_slider_value; + + QHBoxLayout *layout_row5; + QLabel *gps_i_label; + QSlider *gps_i_slider; + QLabel *gps_i_slider_value; + + QHBoxLayout *layout_row6; + QLabel *gps_ac_label; + QButtonGroup *gps_ac_group; + QRadioButton *gps_ac_yes; + QRadioButton *gps_ac_not; + + QVBoxLayout *layout_gui; +}; + +#endif // LATITUDEGUI_H diff --git a/libkqoauth/QtKOAuth b/libkqoauth/QtKOAuth new file mode 100644 index 0000000..ae370fd --- /dev/null +++ b/libkqoauth/QtKOAuth @@ -0,0 +1,5 @@ +#include "kqoauthrequest.h" +#include "kqoauthrequest_1.h" +#include "kqoauthrequest_xauth.h" +#include "kqoauthmanager.h" +#include "kqoauthglobals.h" diff --git a/libkqoauth/kqoauthauthreplyserver.cpp b/libkqoauth/kqoauthauthreplyserver.cpp new file mode 100644 index 0000000..8612f5f --- /dev/null +++ b/libkqoauth/kqoauthauthreplyserver.cpp @@ -0,0 +1,104 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#include +#include +#include + +#include "kqoauthauthreplyserver.h" +#include "kqoauthauthreplyserver_p.h" + +KQOAuthAuthReplyServerPrivate::KQOAuthAuthReplyServerPrivate(KQOAuthAuthReplyServer *parent): + q_ptr(parent) +{ + +} + +KQOAuthAuthReplyServerPrivate::~KQOAuthAuthReplyServerPrivate() +{ + +} + +void KQOAuthAuthReplyServerPrivate::onIncomingConnection() { + Q_Q(KQOAuthAuthReplyServer); + + socket = q->nextPendingConnection(); + connect(socket, SIGNAL(readyRead()), + this, SLOT(onBytesReady()), Qt::UniqueConnection); +} + +void KQOAuthAuthReplyServerPrivate::onBytesReady() { + Q_Q(KQOAuthAuthReplyServer); + + QByteArray reply; + QByteArray content; + content.append("OAuth Finished!

OAuth finished, return to the application!

"); + + reply.append("HTTP/1.0 200 OK \r\n"); + reply.append("Content-Type: text/html; charset=\"utf-8\"\r\n"); + reply.append(QString("Content-Length: %1\r\n").arg(content.size())); + reply.append("\r\n"); + reply.append(content); + socket->write(reply); + + QByteArray data = socket->readAll(); + QMultiMap queryParams = parseQueryParams(&data); + + socket->disconnectFromHost(); + q->close(); + emit q->verificationReceived(queryParams); +} + +QMultiMap KQOAuthAuthReplyServerPrivate::parseQueryParams(QByteArray *data) { + QString splitGetLine = QString(*data).split("\r\n").first(); // Retrieve the first line with query params. + splitGetLine.remove("GET "); // Clean the line from GET + splitGetLine.remove("HTTP/1.1"); // From HTTP + splitGetLine.remove("\r\n"); // And from rest. + splitGetLine.prepend("http://localhost"); // Now, make it a URL + + QUrl getTokenUrl(splitGetLine); + QList< QPair > tokens = getTokenUrl.queryItems(); // Ask QUrl to do our work. + + QMultiMap queryParams; + QPair tokenPair; + foreach (tokenPair, tokens) { + queryParams.insert(tokenPair.first.trimmed(), tokenPair.second.trimmed()); + } + + return queryParams; +} + + + +KQOAuthAuthReplyServer::KQOAuthAuthReplyServer(QObject *parent) : + QTcpServer(parent), + d_ptr( new KQOAuthAuthReplyServerPrivate(this) ) +{ + Q_D(KQOAuthAuthReplyServer); + + connect(this, SIGNAL(newConnection()), + d, SLOT(onIncomingConnection())); +} + +KQOAuthAuthReplyServer::~KQOAuthAuthReplyServer() +{ + delete d_ptr; +} + + diff --git a/libkqoauth/kqoauthauthreplyserver.h b/libkqoauth/kqoauthauthreplyserver.h new file mode 100644 index 0000000..742de2a --- /dev/null +++ b/libkqoauth/kqoauthauthreplyserver.h @@ -0,0 +1,47 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHAUTHREPLYSERVER_H +#define KQOAUTHAUTHREPLYSERVER_H + +#include + +#include "kqoauthglobals.h" + +class KQOAuthAuthReplyServerPrivate; +class KQOAUTH_EXPORT KQOAuthAuthReplyServer : public QTcpServer +{ + Q_OBJECT +public: + explicit KQOAuthAuthReplyServer(QObject *parent); + ~KQOAuthAuthReplyServer(); + +Q_SIGNALS: + void verificationReceived(QMultiMap); + + +private: + KQOAuthAuthReplyServerPrivate * const d_ptr; + Q_DECLARE_PRIVATE(KQOAuthAuthReplyServer); + Q_DISABLE_COPY(KQOAuthAuthReplyServer); + + +}; + +#endif // KQOAUTHAUTHREPLYSERVER_H diff --git a/libkqoauth/kqoauthauthreplyserver_p.h b/libkqoauth/kqoauthauthreplyserver_p.h new file mode 100644 index 0000000..ab0ca9f --- /dev/null +++ b/libkqoauth/kqoauthauthreplyserver_p.h @@ -0,0 +1,47 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +// Note this class shouldn't be copied or used and the implementation might change later. +#ifndef KQOAUTHAUTHREPLYSERVER_P_H +#define KQOAUTHAUTHREPLYSERVER_P_H + +#include "kqoauthauthreplyserver.h" +#include +#include + +class KQOAUTH_EXPORT KQOAuthAuthReplyServerPrivate: public QObject +{ + Q_OBJECT +public: + KQOAuthAuthReplyServerPrivate( KQOAuthAuthReplyServer * parent ); + ~KQOAuthAuthReplyServerPrivate(); + QMultiMap parseQueryParams(QByteArray *sdata); + +public Q_SLOTS: + void onIncomingConnection(); + void onBytesReady(); + +public: + KQOAuthAuthReplyServer * q_ptr; + Q_DECLARE_PUBLIC(KQOAuthAuthReplyServer); + QTcpSocket *socket; + +}; + +#endif // KQOAUTHAUTHREPLYSERVER_P_H diff --git a/libkqoauth/kqoauthglobals.h b/libkqoauth/kqoauthglobals.h new file mode 100644 index 0000000..b48eccc --- /dev/null +++ b/libkqoauth/kqoauthglobals.h @@ -0,0 +1,44 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHGLOBALS_H +#define KQOAUTHGLOBALS_H + +#include + +#if defined(KQOAUTH) +# define KQOAUTH_EXPORT Q_DECL_EXPORT +#else +# define KQOAUTH_EXPORT Q_DECL_IMPORT +#endif + +//////////// Static constant definitions /////////// +const QString OAUTH_KEY_CONSUMER("oauth_consumer"); +const QString OAUTH_KEY_CONSUMER_KEY("oauth_consumer_key"); +const QString OAUTH_KEY_TOKEN("oauth_token"); +const QString OAUTH_KEY_TOKEN_SECRET("oauth_token_secret"); +const QString OAUTH_KEY_SIGNATURE_METHOD("oauth_signature_method"); +const QString OAUTH_KEY_TIMESTAMP("oauth_timestamp"); +const QString OAUTH_KEY_NONCE("oauth_nonce"); +const QString OAUTH_KEY_SIGNATURE("oauth_signature"); +const QString OAUTH_KEY_CALLBACK("oauth_callback"); +const QString OAUTH_KEY_VERIFIER("oauth_verifier"); +const QString OAUTH_KEY_VERSION("oauth_version"); + +#endif // KQOAUTHGLOBALS_H diff --git a/libkqoauth/kqoauthmanager.cpp b/libkqoauth/kqoauthmanager.cpp new file mode 100644 index 0000000..ddd768e --- /dev/null +++ b/libkqoauth/kqoauthmanager.cpp @@ -0,0 +1,492 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#include +// #include + +#include "kqoauthmanager.h" +#include "kqoauthmanager_p.h" + + +////////////// Private d_ptr implementation //////////////// + +KQOAuthManagerPrivate::KQOAuthManagerPrivate(KQOAuthManager *parent) : + error(KQOAuthManager::NoError) , + r(0) , + opaqueRequest(new KQOAuthRequest) , + q_ptr(parent) , + callbackServer(new KQOAuthAuthReplyServer(parent)) , + isVerified(false) , + isAuthorized(false) , + autoAuth(false), + networkManager(new QNetworkAccessManager), + managerUserSet(false) +{ + +} + +KQOAuthManagerPrivate::~KQOAuthManagerPrivate() { + delete opaqueRequest; + opaqueRequest = 0; + + if (!managerUserSet) { + delete networkManager; + networkManager = 0; + } +} + +QList< QPair > KQOAuthManagerPrivate::createQueryParams(const KQOAuthParameters &requestParams) { + QList requestKeys = requestParams.keys(); + QList requestValues = requestParams.values(); + + QList< QPair > result; + for(int i=0; i KQOAuthManagerPrivate::createTokensFromResponse(QByteArray reply) { + QMultiMap result; + QString replyString(reply); + + QStringList parameterPairs = replyString.split('&', QString::SkipEmptyParts); + foreach (const QString ¶meterPair, parameterPairs) { + QStringList parameter = parameterPair.split('='); + result.insert(parameter.value(0), parameter.value(1)); + } + + return result; +} + +bool KQOAuthManagerPrivate::setSuccessfulRequestToken(const QMultiMap &request) { + if (currentRequestType == KQOAuthRequest::TemporaryCredentials) { + hasTemporaryToken = (!QString(request.value("oauth_token")).isEmpty() && !QString(request.value("oauth_token_secret")).isEmpty()); + } else { + return false; + } + + if (hasTemporaryToken) { + requestToken = QUrl::fromPercentEncoding( QString(request.value("oauth_token")).toLocal8Bit() ); + requestTokenSecret = QUrl::fromPercentEncoding( QString(request.value("oauth_token_secret")).toLocal8Bit() ); + } + + return hasTemporaryToken; +} + +bool KQOAuthManagerPrivate::setSuccessfulAuthorized(const QMultiMap &request ) { + if (currentRequestType == KQOAuthRequest::AccessToken) { + isAuthorized = (!QString(request.value("oauth_token")).isEmpty() && !QString(request.value("oauth_token_secret")).isEmpty()); + } else { + return false; + } + + if (isAuthorized) { + requestToken = QUrl::fromPercentEncoding( QString(request.value("oauth_token")).toLocal8Bit() ); + requestTokenSecret = QUrl::fromPercentEncoding( QString(request.value("oauth_token_secret")).toLocal8Bit() ); + } + + return isAuthorized; +} + +void KQOAuthManagerPrivate::emitTokens() { + Q_Q(KQOAuthManager); + + if (this->requestToken.isEmpty() || this->requestTokenSecret.isEmpty()) { + error = KQOAuthManager::RequestUnauthorized; + } + + if (currentRequestType == KQOAuthRequest::TemporaryCredentials) { + // Signal that we are ready to use the protected resources. + emit q->temporaryTokenReceived(this->requestToken, this->requestTokenSecret); + } + + if (currentRequestType == KQOAuthRequest::AccessToken) { + // Signal that we are ready to use the protected resources. + emit q->accessTokenReceived(this->requestToken, this->requestTokenSecret); + } + + emit q->receivedToken(this->requestToken, this->requestTokenSecret); +} + +bool KQOAuthManagerPrivate::setupCallbackServer() { + return callbackServer->listen(); +} + + +/////////////// Public implementation //////////////// + +KQOAuthManager::KQOAuthManager(QObject *parent) : + QObject(parent) , + d_ptr(new KQOAuthManagerPrivate(this)) +{ + +} + +KQOAuthManager::~KQOAuthManager() +{ + delete d_ptr; +} + +void KQOAuthManager::executeRequest(KQOAuthRequest *request) { + Q_D(KQOAuthManager); + + d->r = request; + + if (request == 0) { + qWarning() << "Request is NULL. Cannot proceed."; + d->error = KQOAuthManager::RequestError; + return; + } + + if (!request->requestEndpoint().isValid()) { + qWarning() << "Request endpoint URL is not valid. Cannot proceed."; + d->error = KQOAuthManager::RequestEndpointError; + return; + } + + if (!request->isValid()) { + qWarning() << "Request is not valid. Cannot proceed."; + d->error = KQOAuthManager::RequestValidationError; + return; + } + + d->currentRequestType = request->requestType(); + + QNetworkRequest networkRequest; + networkRequest.setUrl( request->requestEndpoint() ); + + if (d->autoAuth && d->currentRequestType == KQOAuthRequest::TemporaryCredentials) { + d->setupCallbackServer(); + connect(d->callbackServer, SIGNAL(verificationReceived(QMultiMap)), + this, SLOT( onVerificationReceived(QMultiMap))); + + QString serverString = "http://localhost:"; + serverString.append(QString::number(d->callbackServer->serverPort())); + request->setCallbackUrl(QUrl(serverString)); + } + + // And now fill the request with "Authorization" header data. + QList requestHeaders = request->requestParameters(); + QByteArray authHeader; + + bool first = true; + foreach (const QByteArray header, requestHeaders) { + if (!first) { + authHeader.append(", "); + } else { + authHeader.append("OAuth "); + first = false; + } + + authHeader.append(header); + } + networkRequest.setRawHeader("Authorization", authHeader); + + connect(d->networkManager, SIGNAL(finished(QNetworkReply *)), + this, SLOT(onRequestReplyReceived(QNetworkReply *))); + + if (request->httpMethod() == KQOAuthRequest::GET) { + // Get the requested additional params as a list of pairs we can give QUrl + QList< QPair > urlParams = d->createQueryParams(request->additionalParameters()); + + // Take the original URL and append the query params to it. + QUrl urlWithParams = networkRequest.url(); + urlWithParams.setQueryItems(urlParams); + networkRequest.setUrl(urlWithParams); + + // Submit the request including the params. + QNetworkReply *reply = d->networkManager->get(networkRequest); + connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), + this, SLOT(slotError(QNetworkReply::NetworkError))); + + } else if (request->httpMethod() == KQOAuthRequest::POST) { + + networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, request->contentType()); + + qDebug() << networkRequest.rawHeaderList(); + qDebug() << networkRequest.rawHeader("Authorization"); + qDebug() << networkRequest.rawHeader("Content-Type"); + + QNetworkReply *reply; + if (request->contentType() == "application/x-www-form-urlencoded") { + reply = d->networkManager->post(networkRequest, request->requestBody()); + } else { + reply = d->networkManager->post(networkRequest, request->rawData()); + } + + connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), + this, SLOT(slotError(QNetworkReply::NetworkError))); + } + + d->r->requestTimerStart(); +} + + +void KQOAuthManager::setHandleUserAuthorization(bool set) { + Q_D(KQOAuthManager); + + d->autoAuth = set; +} + +bool KQOAuthManager::hasTemporaryToken() { + Q_D(KQOAuthManager); + + return d->hasTemporaryToken; +} + +bool KQOAuthManager::isVerified() { + Q_D(KQOAuthManager); + + return d->isVerified; +} + +bool KQOAuthManager::isAuthorized() { + Q_D(KQOAuthManager); + + return d->isAuthorized; +} + +KQOAuthManager::KQOAuthError KQOAuthManager::lastError() { + Q_D(KQOAuthManager); + + return d->error; +} + +void KQOAuthManager::setNetworkManager(QNetworkAccessManager *manager) { + Q_D(KQOAuthManager); + + if (manager == 0) { + d->error = KQOAuthManager::ManagerError; + return; + } + + if (!d->managerUserSet) { + delete d->networkManager; + } + + d->managerUserSet = true; + d->networkManager = manager; +} + +QNetworkAccessManager * KQOAuthManager::networkManager() const { + Q_D(const KQOAuthManager); + + if (d->managerUserSet) { + return d->networkManager; + } else { + return NULL; + } + +} + + +//////////// Public convenience API ///////////// + +QUrl KQOAuthManager::getUserAuthorization(QUrl authorizationEndpoint) { + Q_D(KQOAuthManager); + + if (!d->hasTemporaryToken) { + qWarning() << "No temporary tokens retreieved. Cannot get user authorization."; + d->error = KQOAuthManager::RequestUnauthorized; + return QString(); + } + + if (!authorizationEndpoint.isValid()) { + qWarning() << "Authorization endpoint not valid. Cannot proceed."; + d->error = KQOAuthManager::RequestEndpointError; + return QString(); + } + + d->error = KQOAuthManager::NoError; + + QPair tokenParam = qMakePair(QString("oauth_token"), QString(d->requestToken)); + QUrl openWebPageUrl(authorizationEndpoint.toString(), QUrl::StrictMode); + openWebPageUrl.addQueryItem(tokenParam.first, tokenParam.second); + + // Open the user's default browser to the resource authorization page provided + // by the service. + // QDesktopServices::openUrl(openWebPageUrl); + qDebug() << "* KQOAuthManager::getUserAuthorization -> QDesktopServices::openUrl" << openWebPageUrl; + return openWebPageUrl; +} + +void KQOAuthManager::getUserAccessTokens(QUrl accessTokenEndpoint) { + Q_D(KQOAuthManager); + + if (!d->isVerified) { + qWarning() << "Not verified. Cannot get access tokens."; + d->error = KQOAuthManager::RequestUnauthorized; + return; + } + + if (!accessTokenEndpoint.isValid()) { + qWarning() << "Endpoint for access token exchange is not valid. Cannot proceed."; + d->error = KQOAuthManager::RequestEndpointError; + return; + } + + d->error = KQOAuthManager::NoError; + + d->opaqueRequest->clearRequest(); + d->opaqueRequest->initRequest(KQOAuthRequest::AccessToken, accessTokenEndpoint); + d->opaqueRequest->setToken(d->requestToken); + d->opaqueRequest->setTokenSecret(d->requestTokenSecret); + d->opaqueRequest->setVerifier(d->requestVerifier); + d->opaqueRequest->setConsumerKey(d->consumerKey); + d->opaqueRequest->setConsumerSecretKey(d->consumerKeySecret); + + executeRequest(d->opaqueRequest); +} + +void KQOAuthManager::sendAuthorizedRequest(QUrl requestEndpoint, const KQOAuthParameters &requestParameters) { + Q_D(KQOAuthManager); + + if (!d->isAuthorized) { + qWarning() << "No access tokens retrieved. Cannot send authorized requests."; + d->error = KQOAuthManager::RequestUnauthorized; + return; + } + + if (!requestEndpoint.isValid()) { + qWarning() << "Endpoint for authorized request is not valid. Cannot proceed."; + d->error = KQOAuthManager::RequestEndpointError; + return; + } + + d->error = KQOAuthManager::NoError; + + d->opaqueRequest->clearRequest(); + d->opaqueRequest->initRequest(KQOAuthRequest::AuthorizedRequest, requestEndpoint); + d->opaqueRequest->setAdditionalParameters(requestParameters); + d->opaqueRequest->setToken(d->requestToken); + d->opaqueRequest->setTokenSecret(d->requestTokenSecret); + d->opaqueRequest->setConsumerKey(d->consumerKey); + d->opaqueRequest->setConsumerSecretKey(d->consumerKeySecret); + + executeRequest(d->opaqueRequest); +} + + +/////////////// Private slots ////////////////// + +void KQOAuthManager::onRequestReplyReceived( QNetworkReply *reply ) { + Q_D(KQOAuthManager); + + QNetworkReply::NetworkError networkError = reply->error(); + switch (networkError) { + case QNetworkReply::NoError: + d->error = KQOAuthManager::NoError; + break; + + case QNetworkReply::ContentAccessDenied: + case QNetworkReply::AuthenticationRequiredError: + d->error = KQOAuthManager::RequestUnauthorized; + break; + + default: + d->error = KQOAuthManager::NetworkError; + break; + } + + // Read the content of the reply from the network. + QByteArray networkReply = reply->readAll(); + + // Stop any timer we have set on the request. + d->r->requestTimerStop(); + + // Just don't do anything if we didn't get anything useful. + if(networkReply.isEmpty()) { + reply->deleteLater(); + return; + } + QMultiMap responseTokens; + + // We need to emit the signal even if we got an error. + if (d->error != KQOAuthManager::NoError) { + reply->deleteLater(); + emit requestReady(networkReply); + d->emitTokens(); + return; + } + + responseTokens = d->createTokensFromResponse(networkReply); + d->opaqueRequest->clearRequest(); + d->opaqueRequest->setHttpMethod(KQOAuthRequest::POST); // XXX FIXME: Convenient API does not support GET + if (!d->isAuthorized || !d->isVerified) { + if (d->setSuccessfulRequestToken(responseTokens)) { + qDebug() << "Successfully got request tokens."; + d->consumerKey = d->r->consumerKeyForManager(); + d->consumerKeySecret = d->r->consumerKeySecretForManager(); + d->opaqueRequest->setSignatureMethod(KQOAuthRequest::HMAC_SHA1); + d->opaqueRequest->setCallbackUrl(d->r->callbackUrlForManager()); + + d->emitTokens(); + + } else if (d->setSuccessfulAuthorized(responseTokens)) { + qDebug() << "Successfully got access tokens."; + d->opaqueRequest->setSignatureMethod(KQOAuthRequest::HMAC_SHA1); + + d->emitTokens(); + } else if (d->currentRequestType == KQOAuthRequest::AuthorizedRequest) { + emit authorizedRequestDone(); + } + } + + emit requestReady(networkReply); + + reply->deleteLater(); // We need to clean this up, after the event processing is done. +} + +void KQOAuthManager::onVerificationReceived(QMultiMap response) { + Q_D(KQOAuthManager); + + QString token = response.value("oauth_token"); + QString verifier = response.value("oauth_verifier"); + if (verifier.isEmpty()) { + d->error = KQOAuthManager::RequestUnauthorized; + } + + verifier = QUrl::fromPercentEncoding(verifier.toUtf8()); // We get the raw URL response here so we need to convert it back + // to plain string so we can percent encode it again later in requests. + + if (d->error == KQOAuthManager::NoError) { + d->requestVerifier = verifier; + d->isVerified = true; + } + + emit authorizationReceived(token, verifier); +} + +void KQOAuthManager::slotError(QNetworkReply::NetworkError error) { + Q_UNUSED(error) + Q_D(KQOAuthManager); + + d->error = KQOAuthManager::NetworkError; + QByteArray emptyResponse; + emit requestReady(emptyResponse); + emit authorizedRequestDone(); + + QNetworkReply *reply = qobject_cast(sender()); + reply->deleteLater(); +} + diff --git a/libkqoauth/kqoauthmanager.h b/libkqoauth/kqoauthmanager.h new file mode 100644 index 0000000..cdd0f4e --- /dev/null +++ b/libkqoauth/kqoauthmanager.h @@ -0,0 +1,177 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHMANAGER_H +#define KQOAUTHMANAGER_H + +#include +#include +#include + +#include "kqoauthrequest.h" + +class KQOAuthRequest; +class KQOAuthManagerThread; +class KQOAuthManagerPrivate; +class QNetworkAccessManager; +class QUrl; +class QByteArray; +class KQOAUTH_EXPORT KQOAuthManager : public QObject +{ + Q_OBJECT +public: + + enum KQOAuthError { + NoError, // No error + NetworkError, // Network error: timeout, cannot connect. + RequestEndpointError, // Request endpoint is not valid. + RequestValidationError, // Request is not valid: some parameter missing? + RequestUnauthorized, // Authorization error: trying to access a resource without tokens. + RequestError, // The given request to KQOAuthManager is invalid: NULL?, + ManagerError // Manager error, cannot use for sending requests. + }; + + explicit KQOAuthManager(QObject *parent = 0); + ~KQOAuthManager(); + + KQOAuthError lastError(); + + /** + * The manager executes the given request. It takes the HTTP parameters from the + * request and uses QNetworkAccessManager to submit the HTTP request to the net. + * When the request is done it will emit signal requestReady(QByteArray networkReply). + * NOTE: At the moment there is no timeout for the request. + */ + void executeRequest(KQOAuthRequest *request); + /** + * Indicates to the user that KQOAuthManager should handle user authorization by + * opening the user's default browser and parsing the reply from the service. + * By setting the parameter to true, KQOAuthManager will store intermediate results + * of the OAuth 1.0 process in its own opaque request. This information is used in + * the user authorization process and also when calling sendAuthorizedRequest(). + * NOTE: You need to set this to true if you want to use getUserAccessTokens() or + * sendAuthorizedRequest(). + */ + void setHandleUserAuthorization(bool set); + + /** + * Returns true if the KQOAuthManager has retrieved the oauth_token value. Otherwise + * return false. + */ + bool hasTemporaryToken(); + /** + * Returns true if the user has authorized us to use the protected resources. Otherwise + * returns false. + * NOTE: In order for KQOAuthManager to know if the user has authorized us to use the + * protected resources, KQOAuthManager must be in control of the user authorization + * process. Hence, this returns true if setHandleUserAuthorization() is set to true + * and the user is authorized with getUserAuthorization(). + */ + bool isVerified(); + /** + * Returns true if KQOAuthManager has the access token and hence can access the protected + * resources. Otherwise returns false. + * NOTE: In order for KQOAuthManager to know if we have access to protected resource + * KQOAuthManager must be in control of the user authorization process and requesting + * the acess token. Hence, this returns true if setHandleUserAuthorization() is set to true + * and the user is authorized with getUserAuthorization() and the access token must be retrieved + * with getUserAccessTokens. + */ + bool isAuthorized(); + + /** + * This is a convenience API for authorizing the user. + * The call will open the user's default browser, setup a local HTTP server and parse the reply from the + * service after the user has authorized us to access protected resources. If the user authorizes + * us to access protected resources, the verifier token is stored in KQOAuthManager for further use. + * In order to use this method, you must set setHandleUserAuthorization() to true. + */ + QUrl getUserAuthorization(QUrl authorizationEndpoint); + /** + * This is a convenience API for retrieving the access token in exchange for the temporary token and the + * verifier. + * This call will create a KQOAuthRequest and use the previously stored temporary token and verifier to + * exchange for the access token, which will be used to access the protected resources. + * Note that in order to use this method, KQOAuthManager must be in control of the user authorization process. + * Set setHandleUserAuthorization() to true and retrieve user authorization with void getUserAuthorization. + */ + void getUserAccessTokens(QUrl accessTokenEndpoint); + /** + * Sends a request to the protected resources. Parameters for the request are service specific and + * are given to the 'requestParameters' as parameters. + * Note that in order to use this method, KQOAuthManager must be in control of the user authorization process. + * Set setHandleUserAuthorization() to true and retrieve user authorization with void getUserAuthorization. + */ + void sendAuthorizedRequest(QUrl requestEndpoint, const KQOAuthParameters &requestParameters); + + /** + * Sets a custom QNetworkAccessManager to handle network requests. This method can be useful if the + * application is using some proxy settings for example. + * The application is responsible for deleting this manager. KQOAuthManager will not delete any + * previously given manager. + * If the manager is NULL, the manager will not be set and the KQOAuthManager::Error. + * If no manager is given, KQOAuthManager will use the default one it will create by itself. + */ + void setNetworkManager(QNetworkAccessManager *manager); + + /** + * Returns the given QNetworkAccessManager. Returns NULL if none is given. + */ + QNetworkAccessManager* networkManager() const; + +Q_SIGNALS: + // This signal will be emitted after each request has got a reply. + // Parameter is the raw response from the service. + void requestReady(QByteArray networkReply); + + // This signal will be emited when we have an request tokens available + // (either temporary resource tokens, or authorization tokens). + void receivedToken(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret + + // This signal is emited when temporary tokens are returned from the service. + // Note that this signal is also emited in case temporary tokens are not available. + void temporaryTokenReceived(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret + + // This signal is emited when the user has authenticated the application to + // communicate with the protected resources. Next we need to exchange the + // temporary tokens for access tokens. + // Note that this signal is also emited if user denies access. + void authorizationReceived(QString oauth_token, QString oauth_verifier); // oauth_token, oauth_verifier + + // This signal is emited when access tokens are received from the service. We are + // ready to start communicating with the protected resources. + void accessTokenReceived(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret + + // This signal is emited when the authorized request is done. + // This ends the kQOAuth interactions. + void authorizedRequestDone(); + +private Q_SLOTS: + void onRequestReplyReceived( QNetworkReply *reply ); + void onVerificationReceived(QMultiMap response); + void slotError(QNetworkReply::NetworkError error); + +private: + KQOAuthManagerPrivate *d_ptr; + Q_DECLARE_PRIVATE(KQOAuthManager); + Q_DISABLE_COPY(KQOAuthManager); + +}; + +#endif // KQOAUTHMANAGER_H diff --git a/libkqoauth/kqoauthmanager_p.h b/libkqoauth/kqoauthmanager_p.h new file mode 100644 index 0000000..ecbbb7b --- /dev/null +++ b/libkqoauth/kqoauthmanager_p.h @@ -0,0 +1,71 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHMANAGER_P_H +#define KQOAUTHMANAGER_P_H + +#include "kqoauthauthreplyserver.h" +#include "kqoauthrequest.h" + +class KQOAUTH_EXPORT KQOAuthManagerPrivate { + +public: + KQOAuthManagerPrivate(KQOAuthManager *parent); + ~KQOAuthManagerPrivate(); + + QList< QPair > createQueryParams(const KQOAuthParameters &requestParams); + QMultiMap createTokensFromResponse(QByteArray reply); + bool setSuccessfulRequestToken(const QMultiMap &request); + bool setSuccessfulAuthorized(const QMultiMap &request); + void emitTokens(); + bool setupCallbackServer(); + + KQOAuthManager::KQOAuthError error; + KQOAuthRequest *r; // This request is used to cache the user sent request. + KQOAuthRequest *opaqueRequest; // This request is used to creating opaque convenience requests for the user. + KQOAuthManager * const q_ptr; + + /** + * The items below are needed in order to store the state of the manager and + * by that be able to do convenience operations for the user. + */ + KQOAuthRequest::RequestType currentRequestType; + + // Variables we store here for opaque request handling. + // NOTE: The variables are labeled the same for both access token request + // and protected resource access. + QString requestToken; + QString requestTokenSecret; + QString consumerKey; + QString consumerKeySecret; + QString requestVerifier; + + KQOAuthAuthReplyServer *callbackServer; + + bool hasTemporaryToken; + bool isVerified; + bool isAuthorized; + bool autoAuth; + QNetworkAccessManager *networkManager; + bool managerUserSet; + + Q_DECLARE_PUBLIC(KQOAuthManager); +}; + +#endif // KQOAUTHMANAGER_P_H diff --git a/libkqoauth/kqoauthrequest.cpp b/libkqoauth/kqoauthrequest.cpp new file mode 100644 index 0000000..1a7b8ca --- /dev/null +++ b/libkqoauth/kqoauthrequest.cpp @@ -0,0 +1,589 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#include +#include +#include +#include +#include + +#include +#include + +#include "kqoauthrequest.h" +#include "kqoauthrequest_p.h" +#include "kqoauthutils.h" +#include "kqoauthglobals.h" + + +//////////// Private d_ptr implementation ///////// + +KQOAuthRequestPrivate::KQOAuthRequestPrivate() : + timeout(0) +{ + +} + +KQOAuthRequestPrivate::~KQOAuthRequestPrivate() +{ + +} + +// This method will not include the "oauthSignature" paramater, since it is calculated from these parameters. +void KQOAuthRequestPrivate::prepareRequest() { + + // If parameter list is not empty, we don't want to insert these values by + // accident a second time. So giving up. + if( !requestParameters.isEmpty() ) { + return; + } + + switch ( requestType ) { + case KQOAuthRequest::TemporaryCredentials: + requestParameters.append( qMakePair( OAUTH_KEY_CALLBACK, oauthCallbackUrl.toString()) ); // This is so ugly that it is almost beautiful. + requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod) ); + requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey )); + requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion )); + requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() )); + requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() )); + break; + + case KQOAuthRequest::AccessToken: + requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod )); + requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey )); + requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion )); + requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() )); + requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() )); + requestParameters.append( qMakePair( OAUTH_KEY_VERIFIER, oauthVerifier )); + requestParameters.append( qMakePair( OAUTH_KEY_TOKEN, oauthToken )); + break; + + case KQOAuthRequest::AuthorizedRequest: + requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod )); + requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey )); + requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion )); + requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() )); + requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() )); + requestParameters.append( qMakePair( OAUTH_KEY_TOKEN, oauthToken )); + break; + + default: + break; + } +} + +void KQOAuthRequestPrivate::signRequest() { + QString signature = this->oauthSignature(); + requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE, signature) ); +} + +QString KQOAuthRequestPrivate::oauthSignature() { + /** + * http://oauth.net/core/1.0/#anchor16 + * The HMAC-SHA1 signature method uses the HMAC-SHA1 signature algorithm as defined in [RFC2104] where the + * Signature Base String is the text and the key is the concatenated values (each first encoded per Parameter + * Encoding) of the Consumer Secret and Token Secret, separated by an ‘&’ character (ASCII code 38) even if empty. + **/ + QByteArray baseString = this->requestBaseString(); + + QString secret = QString(QUrl::toPercentEncoding(oauthConsumerSecretKey)) + "&" + QString(QUrl::toPercentEncoding(oauthTokenSecret)); + QString signature = KQOAuthUtils::hmac_sha1(baseString, secret); + + if (debugOutput) { + qDebug() << "========== KQOAuthRequest has the following signature:"; + qDebug() << " * Signature : " << QUrl::toPercentEncoding(signature) << "\n"; + } + return QString( QUrl::toPercentEncoding(signature) ); +} + +bool normalizedParameterSort(const QPair &left, const QPair &right) { + QString keyLeft = left.first; + QString valueLeft = left.second; + QString keyRight = right.first; + QString valueRight = right.second; + + if(keyLeft == keyRight) { + return (valueLeft < valueRight); + } else { + return (keyLeft < keyRight); + } +} +QByteArray KQOAuthRequestPrivate::requestBaseString() { + QByteArray baseString; + + // Every request has these as the commont parameters. + baseString.append( oauthHttpMethodString.toUtf8() + "&"); // HTTP method + baseString.append( QUrl::toPercentEncoding( oauthRequestEndpoint.toString(QUrl::RemoveQuery) ) + "&" ); // The path and query components + + QList< QPair > baseStringParameters; + baseStringParameters.append(requestParameters); + baseStringParameters.append(additionalParameters); + + // Sort the request parameters. These parameters have been + // initialized earlier. + qSort(baseStringParameters.begin(), + baseStringParameters.end(), + normalizedParameterSort + ); + + // Last append the request parameters correctly encoded. + baseString.append( encodedParamaterList(baseStringParameters) ); + + if (debugOutput) { + qDebug() << "========== KQOAuthRequest has the following base string:"; + qDebug() << baseString << "\n"; + } + + return baseString; +} + +QByteArray KQOAuthRequestPrivate::encodedParamaterList(const QList< QPair > ¶meters) { + QByteArray resultList; + + bool first = true; + QPair parameter; + + // Do the debug output. + if (debugOutput) { + qDebug() << "========== KQOAuthRequest has the following parameters:"; + } + foreach (parameter, parameters) { + if(!first) { + resultList.append( "&" ); + } else { + first = false; + } + + // Here we don't need to explicitely encode the strings to UTF-8 since + // QUrl::toPercentEncoding() takes care of that for us. + resultList.append( QUrl::toPercentEncoding(parameter.first) // Parameter key + + "=" + + QUrl::toPercentEncoding(parameter.second) // Parameter value + ); + if (debugOutput) { + qDebug() << " * " + << parameter.first + << " : " + << parameter.second; + } + } + if (debugOutput) { + qDebug() << "\n"; + } + + return QUrl::toPercentEncoding(resultList); +} + +QString KQOAuthRequestPrivate::oauthTimestamp() const { + // This is basically for unit tests only. In most cases we don't set the nonce beforehand. + if (!oauthTimestamp_.isEmpty()) { + return oauthTimestamp_; + } + +#if QT_VERSION >= 0x040700 + return QString::number(QDateTime::currentDateTimeUtc().toTime_t()); +#else + return QString::number(QDateTime::currentDateTime().toUTC().toTime_t()); +#endif + +} + +QString KQOAuthRequestPrivate::oauthNonce() const { + // This is basically for unit tests only. In most cases we don't set the nonce beforehand. + if (!oauthNonce_.isEmpty()) { + return oauthNonce_; + } + + return QString::number(qrand()); +} + +bool KQOAuthRequestPrivate::validateRequest() const { + switch ( requestType ) { + case KQOAuthRequest::TemporaryCredentials: + if (oauthRequestEndpoint.isEmpty() + || oauthConsumerKey.isEmpty() + || oauthNonce_.isEmpty() + || oauthSignatureMethod.isEmpty() + || oauthTimestamp_.isEmpty() + || oauthVersion.isEmpty()) + { + return false; + } + return true; + + case KQOAuthRequest::AccessToken: + if (oauthRequestEndpoint.isEmpty() + || oauthVerifier.isEmpty() + || oauthConsumerKey.isEmpty() + || oauthNonce_.isEmpty() + || oauthSignatureMethod.isEmpty() + || oauthTimestamp_.isEmpty() + || oauthToken.isEmpty() + || oauthTokenSecret.isEmpty() + || oauthVersion.isEmpty()) + { + return false; + } + return true; + + case KQOAuthRequest::AuthorizedRequest: + if (oauthRequestEndpoint.isEmpty() + || oauthConsumerKey.isEmpty() + || oauthNonce_.isEmpty() + || oauthSignatureMethod.isEmpty() + || oauthTimestamp_.isEmpty() + || oauthToken.isEmpty() + || oauthTokenSecret.isEmpty() + || oauthVersion.isEmpty()) + { + return false; + } + return true; + + default: + return false; + } + + // We should not come here. + return false; +} + +//////////// Public implementation //////////////// + +KQOAuthRequest::KQOAuthRequest(QObject *parent) : + QObject(parent), + d_ptr(new KQOAuthRequestPrivate) +{ + d_ptr->debugOutput = false; // No debug output by default. + qsrand(QTime::currentTime().msec()); // We need to seed the nonce random number with something. + // However, we cannot do this while generating the nonce since + // we might get the same seed. So initializing here should be fine. +} + +KQOAuthRequest::~KQOAuthRequest() +{ + delete d_ptr; +} + +void KQOAuthRequest::initRequest(KQOAuthRequest::RequestType type, const QUrl &requestEndpoint) { + Q_D(KQOAuthRequest); + + if (!requestEndpoint.isValid()) { + qWarning() << "Endpoint URL is not valid. Ignoring. This request might not work."; + return; + } + + if (type < 0 || type > KQOAuthRequest::AuthorizedRequest) { + qWarning() << "Invalid request type. Ignoring. This request might not work."; + return; + } + + // Clear the request + clearRequest(); + + // Set smart defaults. + d->requestType = type; + d->oauthRequestEndpoint = requestEndpoint; + d->oauthTimestamp_ = d->oauthTimestamp(); + d->oauthNonce_ = d->oauthNonce(); + this->setSignatureMethod(KQOAuthRequest::HMAC_SHA1); + this->setHttpMethod(KQOAuthRequest::POST); + d->oauthVersion = "1.0"; // Currently supports only version 1.0 + + d->contentType = "application/x-www-form-urlencoded"; +} + +void KQOAuthRequest::setConsumerKey(const QString &consumerKey) { + Q_D(KQOAuthRequest); + d->oauthConsumerKey = consumerKey; +} + +void KQOAuthRequest::setConsumerSecretKey(const QString &consumerSecretKey) { + Q_D(KQOAuthRequest); + d->oauthConsumerSecretKey = consumerSecretKey; +} + +void KQOAuthRequest::setCallbackUrl(const QUrl &callbackUrl) { + Q_D(KQOAuthRequest); + + d->oauthCallbackUrl = callbackUrl; +} + +void KQOAuthRequest::setSignatureMethod(KQOAuthRequest::RequestSignatureMethod requestMethod) { + Q_D(KQOAuthRequest); + QString requestMethodString; + + switch (requestMethod) { + case KQOAuthRequest::PLAINTEXT: + requestMethodString = "PLAINTEXT"; + break; + case KQOAuthRequest::HMAC_SHA1: + requestMethodString = "HMAC-SHA1"; + break; + case KQOAuthRequest::RSA_SHA1: + requestMethodString = "RSA-SHA1"; + break; + default: + // We should not come here + qWarning() << "Invalid signature method set."; + break; + } + + d->oauthSignatureMethod = requestMethodString; +} + +void KQOAuthRequest::setTokenSecret(const QString &tokenSecret) { + Q_D(KQOAuthRequest); + + d->oauthTokenSecret = tokenSecret; +} + +void KQOAuthRequest::setToken(const QString &token) { + Q_D(KQOAuthRequest); + + d->oauthToken = token; +} + +void KQOAuthRequest::setVerifier(const QString &verifier) { + Q_D(KQOAuthRequest); + + d->oauthVerifier = verifier; +} + + +void KQOAuthRequest::setHttpMethod(KQOAuthRequest::RequestHttpMethod httpMethod) { + Q_D(KQOAuthRequest); + + QString requestHttpMethodString; + + switch (httpMethod) { + case KQOAuthRequest::GET: + requestHttpMethodString = "GET"; + break; + case KQOAuthRequest::POST: + requestHttpMethodString = "POST"; + break; + default: + qWarning() << "Invalid HTTP method set."; + break; + } + + d->oauthHttpMethod = httpMethod; + d->oauthHttpMethodString = requestHttpMethodString; +} + +KQOAuthRequest::RequestHttpMethod KQOAuthRequest::httpMethod() const { + Q_D(const KQOAuthRequest); + + return d->oauthHttpMethod; +} + +void KQOAuthRequest::setAdditionalParameters(const KQOAuthParameters &additionalParams) { + Q_D(KQOAuthRequest); + + QList additionalKeys = additionalParams.keys(); + QList additionalValues = additionalParams.values(); + + int i=0; + foreach(QString key, additionalKeys) { + QString value = additionalValues.at(i); + d->additionalParameters.append( qMakePair(key, value) ); + i++; + } +} + +KQOAuthParameters KQOAuthRequest::additionalParameters() const { + Q_D(const KQOAuthRequest); + + QMultiMap additionalParams; + for(int i=0; iadditionalParameters.size(); i++) { + additionalParams.insert(d->additionalParameters.at(i).first, + d->additionalParameters.at(i).second); + } + + return additionalParams; +} + +KQOAuthRequest::RequestType KQOAuthRequest::requestType() const { + Q_D(const KQOAuthRequest); + return d->requestType; +} + +QUrl KQOAuthRequest::requestEndpoint() const { + Q_D(const KQOAuthRequest); + return d->oauthRequestEndpoint; +} + +QList KQOAuthRequest::requestParameters() { + Q_D(KQOAuthRequest); + + QList requestParamList; + + d->prepareRequest(); + if (!isValid() ) { + qWarning() << "Request is not valid! I will still sign it, but it will probably not work."; + } + d->signRequest(); + + QPair requestParam; + QString param; + QString value; + foreach (requestParam, d->requestParameters) { + param = requestParam.first; + value = requestParam.second; + requestParamList.append(QString(param + "=\"" + value +"\"").toUtf8()); + } + + return requestParamList; +} + +QString KQOAuthRequest::contentType() +{ + Q_D(const KQOAuthRequest); + return d->contentType; +} + +void KQOAuthRequest::setContentType(const QString &contentType) +{ + Q_D(KQOAuthRequest); + d->contentType = contentType; +} + +QByteArray KQOAuthRequest::rawData() +{ + Q_D(const KQOAuthRequest); + return d->postRawData; +} + +void KQOAuthRequest::setRawData(const QByteArray &rawData) +{ + Q_D(KQOAuthRequest); + d->postRawData = rawData; +} + +QByteArray KQOAuthRequest::requestBody() const { + Q_D(const KQOAuthRequest); + + QByteArray postBodyContent; + bool first = true; + for(int i=0; i < d->additionalParameters.size(); i++) { + if(!first) { + postBodyContent.append("&"); + } else { + first = false; + } + + QString key = d->additionalParameters.at(i).first; + QString value = d->additionalParameters.at(i).second; + + postBodyContent.append(QUrl::toPercentEncoding(key) + QString("=").toUtf8() + + QUrl::toPercentEncoding(value)); + } + return postBodyContent; +} + +bool KQOAuthRequest::isValid() const { + Q_D(const KQOAuthRequest); + + return d->validateRequest(); +} + +void KQOAuthRequest::setTimeout(int timeoutMilliseconds) { + Q_D(KQOAuthRequest); + d->timeout = timeoutMilliseconds; +} + +void KQOAuthRequest::clearRequest() { + Q_D(KQOAuthRequest); + + d->oauthRequestEndpoint = ""; + d->oauthHttpMethodString = ""; + d->oauthConsumerKey = ""; + d->oauthConsumerSecretKey = ""; + d->oauthToken = ""; + d->oauthTokenSecret = ""; + d->oauthSignatureMethod = ""; + d->oauthCallbackUrl = ""; + d->oauthVerifier = ""; + d->oauthTimestamp_ = ""; + d->oauthNonce_ = ""; + d->requestParameters.clear(); + d->additionalParameters.clear(); + d->timeout = 0; +} + +void KQOAuthRequest::setEnableDebugOutput(bool enabled) { + Q_D(KQOAuthRequest); + d->debugOutput = enabled; +} + +/** + * Protected implementations for inherited classes + */ +bool KQOAuthRequest::validateXAuthRequest() const { + Q_D(const KQOAuthRequest); + + if (d->oauthRequestEndpoint.isEmpty() + || d->oauthConsumerKey.isEmpty() + || d->oauthNonce_.isEmpty() + || d->oauthSignatureMethod.isEmpty() + || d->oauthTimestamp_.isEmpty() + || d->oauthVersion.isEmpty()) + { + return false; + } + return true; +} + + +/** + * Private implementations for friend classes + */ +QString KQOAuthRequest::consumerKeyForManager() const { + Q_D(const KQOAuthRequest); + return d->oauthConsumerKey; +} + +QString KQOAuthRequest::consumerKeySecretForManager() const { + Q_D(const KQOAuthRequest); + return d->oauthConsumerSecretKey; +} + +QUrl KQOAuthRequest::callbackUrlForManager() const { + Q_D(const KQOAuthRequest); + return d->oauthCallbackUrl; +} + +void KQOAuthRequest::requestTimerStart() +{ + Q_D(KQOAuthRequest); + if (d->timeout > 0) { + connect(&(d->timer), SIGNAL(timeout()), this, SIGNAL(requestTimedout())); + d->timer.start(d->timeout); + } +} + +void KQOAuthRequest::requestTimerStop() +{ + Q_D(KQOAuthRequest); + if (d->timeout > 0) { + disconnect(&(d->timer), SIGNAL(timeout()), this, SIGNAL(requestTimedout())); + d->timer.stop(); + } +} diff --git a/libkqoauth/kqoauthrequest.h b/libkqoauth/kqoauthrequest.h new file mode 100644 index 0000000..687daaf --- /dev/null +++ b/libkqoauth/kqoauthrequest.h @@ -0,0 +1,145 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHREQUEST_H +#define KQOAUTHREQUEST_H + +#include +#include +#include + +#include "kqoauthglobals.h" + +typedef QMultiMap KQOAuthParameters; + +class KQOAuthRequestPrivate; +class KQOAUTH_EXPORT KQOAuthRequest : public QObject +{ + Q_OBJECT +public: + explicit KQOAuthRequest(QObject *parent = 0); + ~KQOAuthRequest(); + + enum RequestType { + TemporaryCredentials = 0, + AccessToken, + AuthorizedRequest + }; + + enum RequestSignatureMethod { + PLAINTEXT = 0, + HMAC_SHA1, + RSA_SHA1 + }; + + enum RequestHttpMethod { + GET = 0, + POST + }; + + /** + * These methods can be overridden in child classes which are different types of + * OAuth requests. + */ + // Validate the request of this type. + virtual bool isValid() const; + + /** + * These methods are OAuth request type specific and not overridden in child + * classes. + * NOTE: Refactorting still a TODO + */ + // Initialize the request of this type. + void initRequest(KQOAuthRequest::RequestType type, const QUrl &requestEndpoint); + + void setConsumerKey(const QString &consumerKey); + void setConsumerSecretKey(const QString &consumerSecretKey); + + // Mandatory methods for acquiring a request token + void setCallbackUrl(const QUrl &callbackUrl); + + // Mandator methods for acquiring a access token + void setTokenSecret(const QString &tokenSecret); + void setToken(const QString &token); + void setVerifier(const QString &verifier); + + // Request signature method to use - HMAC_SHA1 currently only supported + void setSignatureMethod(KQOAuthRequest::RequestSignatureMethod = KQOAuthRequest::HMAC_SHA1); + + // Request's HTTP method. + void setHttpMethod(KQOAuthRequest::RequestHttpMethod = KQOAuthRequest::POST); + KQOAuthRequest::RequestHttpMethod httpMethod() const; + + // Sets the timeout for this request. If the timeout expires, signal "requestTimedout" will be + // emitted from the manager. + // 0 = If set to zero, timeout is disabled. + // TODO: Do we need some request ID now? + void setTimeout(int timeoutMilliseconds); + + // Additional optional parameters to the request. + void setAdditionalParameters(const KQOAuthParameters &additionalParams); + KQOAuthParameters additionalParameters() const; + QList requestParameters(); // This will return all request's parameters in the raw format given + // to the QNetworkRequest. + QByteArray requestBody() const; // This will return the POST body as given to the QNetworkRequest. + + KQOAuthRequest::RequestType requestType() const; + QUrl requestEndpoint() const; + + void setContentType(const QString &contentType); + QString contentType(); + + void setRawData(const QByteArray &rawData); + QByteArray rawData(); + + void clearRequest(); + + // Enable verbose debug output for request content. + void setEnableDebugOutput(bool enabled); + +Q_SIGNALS: + // This signal is emited if the request is not completed before the request's timeout + // value has expired. + void requestTimedout(); + +protected: + bool validateXAuthRequest() const; + +private: + KQOAuthRequestPrivate * const d_ptr; + Q_DECLARE_PRIVATE(KQOAuthRequest); + Q_DISABLE_COPY(KQOAuthRequest); + + // These classes are only for the internal use of KQOAuthManager so it can + // work with the opaque request. + QString consumerKeyForManager() const; + QString consumerKeySecretForManager() const; + QUrl callbackUrlForManager() const; + + // This method is for timeout handling by the KQOAuthManager. + void requestTimerStart(); + void requestTimerStop(); + + friend class KQOAuthManager; +#ifdef UNIT_TEST + friend class Ut_KQOAuth; +#endif +}; + +#endif // KQOAUTHREQUEST_H diff --git a/libkqoauth/kqoauthrequest_1.cpp b/libkqoauth/kqoauthrequest_1.cpp new file mode 100644 index 0000000..85449cf --- /dev/null +++ b/libkqoauth/kqoauthrequest_1.cpp @@ -0,0 +1,5 @@ +#include "kqoauthrequest_1.h" + +KQOAuthRequest_1::KQOAuthRequest_1() +{ +} diff --git a/libkqoauth/kqoauthrequest_1.h b/libkqoauth/kqoauthrequest_1.h new file mode 100644 index 0000000..aecf90f --- /dev/null +++ b/libkqoauth/kqoauthrequest_1.h @@ -0,0 +1,12 @@ +#ifndef KQOAUTHREQUEST_1_H +#define KQOAUTHREQUEST_1_H + +#include "kqoauthrequest.h" + +class KQOAUTH_EXPORT KQOAuthRequest_1 : public KQOAuthRequest +{ +public: + KQOAuthRequest_1(); +}; + +#endif // KQOAUTHREQUEST_1_H diff --git a/libkqoauth/kqoauthrequest_p.h b/libkqoauth/kqoauthrequest_p.h new file mode 100644 index 0000000..cfbf82e --- /dev/null +++ b/libkqoauth/kqoauthrequest_p.h @@ -0,0 +1,93 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHREQUEST_P_H +#define KQOAUTHREQUEST_P_H +#include "kqoauthglobals.h" +#include "kqoauthrequest.h" + +#include +#include +#include +#include +#include +#include + +class KQOAUTH_EXPORT KQOAuthRequestPrivate { + +public: + KQOAuthRequestPrivate(); + ~KQOAuthRequestPrivate(); + + // Helper methods to get the values for the OAuth request parameters. + QString oauthTimestamp() const; + QString oauthNonce() const; + QString oauthSignature(); + + // Utility methods for making the request happen. + void prepareRequest(); + void signRequest(); + bool validateRequest() const; + QByteArray requestBaseString(); + QByteArray encodedParamaterList(const QList< QPair > &requestParameters); + void insertAdditionalParams(); + void insertPostBody(); + + QUrl oauthRequestEndpoint; + KQOAuthRequest::RequestHttpMethod oauthHttpMethod; + QString oauthHttpMethodString; + QString oauthConsumerKey; + QString oauthConsumerSecretKey; + QString oauthToken; + QString oauthTokenSecret; + QString oauthSignatureMethod; + QUrl oauthCallbackUrl; + QString oauthVersion; + QString oauthVerifier; + + // These will be generated by the helper methods + QString oauthTimestamp_; + QString oauthNonce_; + + // User specified additional parameters needed for the request. + QList< QPair > additionalParameters; + + // The raw POST body content as given to the HTTP request. + QByteArray postBodyContent; + + // Protocol parameters. + // These parameters are used in the "Authorized" header of the HTTP request. + QList< QPair > requestParameters; + + KQOAuthRequest::RequestType requestType; + + //The Content-Type HTTP header + QString contentType; + + //Raw data to post if type is not url-encoded + QByteArray postRawData; + + // Timeout for this request in milliseconds. + int timeout; + QTimer timer; + + bool debugOutput; + +}; +#endif // KQOAUTHREQUEST_P_H diff --git a/libkqoauth/kqoauthrequest_xauth.cpp b/libkqoauth/kqoauthrequest_xauth.cpp new file mode 100644 index 0000000..92aab5f --- /dev/null +++ b/libkqoauth/kqoauthrequest_xauth.cpp @@ -0,0 +1,89 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#include + +#include "kqoauthrequest_xauth_p.h" +#include "kqoauthrequest_xauth.h" + +/** + * Private d_ptr implementations. + */ +KQOAuthRequest_XAuthPrivate::KQOAuthRequest_XAuthPrivate() +{ + +} + +KQOAuthRequest_XAuthPrivate::~KQOAuthRequest_XAuthPrivate() +{ +} + +/** + * Public implementations. + */ +KQOAuthRequest_XAuth::KQOAuthRequest_XAuth(QObject *parent) : + KQOAuthRequest(parent), + d_ptr(new KQOAuthRequest_XAuthPrivate) +{ +} + +bool KQOAuthRequest_XAuth::isValid() const { + // An xAuth can never request temporary credentials. + if (requestType() == KQOAuthRequest::TemporaryCredentials) { + qWarning() << "XAuth request cannot be of type KQOAuthRequest::TemporaryCredentials. Aborting."; + return false; + } + + // Access token must always be retrieved using the POST HTTP method. + if (requestType() == KQOAuthRequest::AccessToken + && httpMethod() != KQOAuthRequest::POST) { + + qWarning() << "Access tokens must be fetched using the POST HTTP method. Aborting."; + + return false; + } + + if (!xauth_parameters_set) { + qWarning() << "No XAuth parameters set. Aborting."; + return false; + } + + // And then check the validity of the XAuth request. + // Provided by the base class as a protected method for us. + return validateXAuthRequest(); +} + +void KQOAuthRequest_XAuth::setXAuthLogin(const QString &username, + const QString &password) { + + if (username.isEmpty() || password.isEmpty()) { + qWarning() << "Username or password cannot be empty. Aborting."; + return; + } + + xauth_parameters_set = true; + + KQOAuthParameters xauthParams; + xauthParams.insert("x_auth_username", username); + xauthParams.insert("x_auth_password", password); + xauthParams.insert("x_auth_mode", "client_auth"); + + setAdditionalParameters(xauthParams); +} + diff --git a/libkqoauth/kqoauthrequest_xauth.h b/libkqoauth/kqoauthrequest_xauth.h new file mode 100644 index 0000000..4b12b70 --- /dev/null +++ b/libkqoauth/kqoauthrequest_xauth.h @@ -0,0 +1,49 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHREQUEST_XAUTH_H +#define KQOAUTHREQUEST_XAUTH_H + +#include "kqoauthrequest.h" +#include "kqoauthrequest_1.h" + +class KQOAuthRequest_XAuthPrivate; +class KQOAUTH_EXPORT KQOAuthRequest_XAuth : public KQOAuthRequest +{ + Q_OBJECT +public: + KQOAuthRequest_XAuth(QObject *parent = 0); + + /** + * These methods can be overridden in child classes which are different types of + * OAuth requests. + */ + // Validate the request of this type. + bool isValid() const; + + // Give the xAuth specific parameters. + void setXAuthLogin(const QString &username = "", + const QString &password = ""); + +private: + KQOAuthRequest_XAuthPrivate * const d_ptr; + bool xauth_parameters_set; +}; + +#endif // KQOAUTHREQUEST_XAUTH_H diff --git a/libkqoauth/kqoauthrequest_xauth_p.h b/libkqoauth/kqoauthrequest_xauth_p.h new file mode 100644 index 0000000..bc3ac4f --- /dev/null +++ b/libkqoauth/kqoauthrequest_xauth_p.h @@ -0,0 +1,14 @@ +#ifndef KQOAUTHREQUEST_XAUTH_P_H +#define KQOAUTHREQUEST_XAUTH_P_H + +#include "kqoauthglobals.h" + +class KQOAuthRequest; +class KQOAUTH_EXPORT KQOAuthRequest_XAuthPrivate +{ +public: + KQOAuthRequest_XAuthPrivate(); + ~KQOAuthRequest_XAuthPrivate(); +}; + +#endif // KQOAUTHREQUEST_XAUTH_P_H diff --git a/libkqoauth/kqoauthutils.cpp b/libkqoauth/kqoauthutils.cpp new file mode 100644 index 0000000..d6518a7 --- /dev/null +++ b/libkqoauth/kqoauthutils.cpp @@ -0,0 +1,79 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#include +#include +#include + +#include +#include "kqoauthutils.h" + +QString KQOAuthUtils::hmac_sha1(const QString &message, const QString &key) +{ + QByteArray keyBytes = key.toAscii(); + int keyLength; // Lenght of key word + const int blockSize = 64; // Both MD5 and SHA-1 have a block size of 64. + + keyLength = keyBytes.size(); + // If key is longer than block size, we need to hash the key + if (keyLength > blockSize) { + QCryptographicHash hash(QCryptographicHash::Sha1); + hash.addData(keyBytes); + keyBytes = hash.result(); + } + + /* http://tools.ietf.org/html/rfc2104 - (1) */ + // Create the opad and ipad for the hash function. + QByteArray ipad; + QByteArray opad; + + ipad.fill( 0, blockSize); + opad.fill( 0, blockSize); + + ipad.replace(0, keyBytes.length(), keyBytes); + opad.replace(0, keyBytes.length(), keyBytes); + + /* http://tools.ietf.org/html/rfc2104 - (2) & (5) */ + for (int i=0; i<64; i++) { + ipad[i] = ipad[i] ^ 0x36; + opad[i] = opad[i] ^ 0x5c; + } + + QByteArray workArray; + workArray.clear(); + + workArray.append(ipad, 64); + /* http://tools.ietf.org/html/rfc2104 - (3) */ + workArray.append(message.toAscii()); + + + /* http://tools.ietf.org/html/rfc2104 - (4) */ + QByteArray sha1 = QCryptographicHash::hash(workArray, QCryptographicHash::Sha1); + + /* http://tools.ietf.org/html/rfc2104 - (6) */ + workArray.clear(); + workArray.append(opad, 64); + workArray.append(sha1); + + sha1.clear(); + + /* http://tools.ietf.org/html/rfc2104 - (7) */ + sha1 = QCryptographicHash::hash(workArray, QCryptographicHash::Sha1); + return QString(sha1.toBase64()); +} diff --git a/libkqoauth/kqoauthutils.h b/libkqoauth/kqoauthutils.h new file mode 100644 index 0000000..bb9edbb --- /dev/null +++ b/libkqoauth/kqoauthutils.h @@ -0,0 +1,33 @@ +/** + * KQOAuth - An OAuth authentication library for Qt. + * + * Author: Johan Paul (johan.paul@d-pointer.com) + * http://www.d-pointer.com + * + * KQOAuth is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * KQOAuth 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with KQOAuth. If not, see . + */ +#ifndef KQOAUTHUTILS_H +#define KQOAUTHUTILS_H + +#include "kqoauthglobals.h" + +class QString; +class KQOAUTH_EXPORT KQOAuthUtils +{ +public: + + static QString hmac_sha1(const QString &message, const QString &key); +}; + +#endif // KQOAUTHUTILS_H diff --git a/main-daemon.cpp b/main-daemon.cpp new file mode 100644 index 0000000..be44174 --- /dev/null +++ b/main-daemon.cpp @@ -0,0 +1,16 @@ +#include +#include "latitudedaemon.h" + +int main(int argc, char *argv[]) { + qDebug() << "* main"; + QCoreApplication::setOrganizationName("linfati.com"); + QCoreApplication::setOrganizationDomain("linfati.com"); + QCoreApplication::setApplicationName("latitudeupdater"); + + QCoreApplication lu(argc, argv); + + LatitudeDaemon mygui; + Q_UNUSED(mygui) + + return lu.exec(); +} diff --git a/main-qml.cpp b/main-qml.cpp new file mode 100644 index 0000000..1b6b9eb --- /dev/null +++ b/main-qml.cpp @@ -0,0 +1,15 @@ +#include +#include "latitudeqml.h" + +int main(int argc, char *argv[]) { + qDebug() << "* main"; + QCoreApplication::setOrganizationName("linfati.com"); + QCoreApplication::setOrganizationDomain("linfati.com"); + QCoreApplication::setApplicationName("latitudeupdater"); + + QApplication lu(argc, argv); + LatitudeQML mygui; + mygui.show(); + + return lu.exec(); +} diff --git a/main-widget.cpp b/main-widget.cpp new file mode 100644 index 0000000..111498a --- /dev/null +++ b/main-widget.cpp @@ -0,0 +1,15 @@ +#include +#include "latitudewidget.h" + +int main(int argc, char *argv[]) { + qDebug() << "* main"; + QCoreApplication::setOrganizationName("linfati.com"); + QCoreApplication::setOrganizationDomain("linfati.com"); + QCoreApplication::setApplicationName("latitudeupdater"); + + QApplication lu(argc, argv); + LatitudeGUI mygui; + mygui.show(); + + return lu.exec(); +} diff --git a/not_used/glupdater b/not_used/glupdater new file mode 100644 index 0000000..62c9362 --- /dev/null +++ b/not_used/glupdater @@ -0,0 +1,13 @@ +author "Danilo Luvizotto " +description "Google Latitude Updater Daemon" + +start on started hildon-desktop + +console output + +post-stop script + killall -9 GoogleLatitudeDaemon +end script + +exec /bin/su - user -c "/opt/linfati.com/GoogleLatitudeDaemon --init" + diff --git a/not_used/gpsmaemo5.cpp b/not_used/gpsmaemo5.cpp new file mode 100644 index 0000000..e5c8869 --- /dev/null +++ b/not_used/gpsmaemo5.cpp @@ -0,0 +1,110 @@ +#include "gps.h" + +GpsMaemo5::GpsMaemo5(QObject *parent) : + QObject(parent), + latitude(0), longitude(0), accuracy(0), + interval(1800), wait(30), method("cell"), + emitfix(false), stopgps(true) { +#ifdef Q_WS_MAEMO_5 + control = location_gpsd_control_get_default(); + device = (LocationGPSDevice*) g_object_new(LOCATION_TYPE_GPS_DEVICE, NULL); + g_signal_connect(device, "changed", G_CALLBACK(GpsMaemo5_changed), this); +#else + urlloc = QUrl::fromEncoded("http://www.google.com/loc/json"); + worker = new QNetworkAccessManager(); + connect(worker, SIGNAL(finished(QNetworkReply *)), this, SLOT(gloc_reply(QNetworkReply *))); +#endif // Q_WS_MAEMO_5 +} + +void GpsMaemo5::refresh() { + if ( stopgps ) return; + qDebug() << "GpsMaemo5: refresh"; + + QTimer::singleShot(interval*1000, this, SLOT(refresh())); + QTimer::singleShot(wait*1000, this, SLOT(stop())); + +#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) + QNetworkConfigurationManager mgr; + if (!mgr.isOnline()) { + qDebug() << "GpsMaemo5: offline"; + return; + } +#endif + +#ifdef Q_WS_MAEMO_5 + if ( method == QString("cell") ) { + g_object_set(G_OBJECT(control), "preferred-method", LOCATION_METHOD_ACWP, NULL); + } else if ( method == QString("both") ) { + g_object_set(G_OBJECT(control), "preferred-method", LOCATION_METHOD_USER_SELECTED, NULL); + } else if ( method == QString("agps") ) { + g_object_set(G_OBJECT(control), "preferred-method", LOCATION_METHOD_AGNSS, NULL); + } else { + g_object_set(G_OBJECT(control), "preferred-method", LOCATION_METHOD_ACWP, NULL); + } + location_gpsd_control_start(control); +#else + worker->post(QNetworkRequest(urlloc), QByteArray("{version:\"1.1.0\"}")); +#endif // Q_WS_MAEMO_5 +} + +void GpsMaemo5::stop() { + qDebug() << "GpsMaemo5: stop"; +#ifdef Q_WS_MAEMO_5 + location_gpsd_control_stop(control); +#else +#endif // Q_WS_MAEMO_5 + if (emitfix) { + emitfix = false; + emit fix(); + } +} + +void GpsMaemo5::forcestop() { + qDebug() << "GpsMaemo5: forcestop"; + stopgps = true; + emitfix = false; + stop(); +} + +int GpsMaemo5::config(int i, int w, QString m) { + qDebug() << "GpsMaemo5: config"; + stopgps = false; + interval = i; + wait = w; + method = m; + return 0; +} + +#ifdef Q_WS_MAEMO_5 +void GpsMaemo5_changed(LocationGPSDevice *device, GpsMaemo5 *gps) { + if (device->fix) { + if (device->fix->fields) { + if ( isnan(gps->device->fix->eph) ) return; + g_print("GpsMaemo5 lat %f lon %f eph %f\n", gps->device->fix->latitude, gps->device->fix->longitude, gps->device->fix->eph/100.); + gps->latitude = gps->device->fix->latitude; + gps->longitude = gps->device->fix->longitude; + gps->accuracy = gps->device->fix->eph/100.; + gps->emitfix = true; + } + } +} +#else +void GpsMaemo5::gloc_reply(QNetworkReply *r) { + if ( r->url() == urlloc ) { + QString loc = r->readAll(); + QRegExp regexp ("\\{\"latitude\":(.*),\"longitude\":(.*),\"accuracy\":(.*)\\}"); + regexp.setMinimal(1); + regexp.indexIn(loc, 1); + latitude = regexp.capturedTexts().at(1).toDouble(); + longitude = regexp.capturedTexts().at(2).toDouble(); + accuracy = regexp.capturedTexts().at(3).toDouble(); + if ( accuracy > 100000 ) accuracy = 100000; + qDebug() << "GpsIP lat" << latitude << "lon" << longitude << "acc" << accuracy; + emitfix = true; + } else { + qDebug() << "GpsIP Error url" << r->url(); + qDebug() << r->rawHeaderList(); + qDebug() << r->readAll(); + } +} +#endif // Q_WS_MAEMO_5 diff --git a/not_used/gpsmaemo5.h b/not_used/gpsmaemo5.h new file mode 100644 index 0000000..c0ba709 --- /dev/null +++ b/not_used/gpsmaemo5.h @@ -0,0 +1,63 @@ +#ifndef GPS_H +#define GPS_H + +#include +#include + +#ifdef Q_WS_MAEMO_5 +extern "C" { +#include +#include +} +#else +#include +#endif // Q_WS_MAEMO_5 + +class GpsMaemo5 : public QObject { + Q_OBJECT + +signals: + void fix(); + +public: + GpsMaemo5(QObject *parent = 0); + double get_lat() { return latitude; } + double get_lon() { return longitude; } + double get_acc() { return accuracy; } + +public slots: + void refresh(); + void stop(); + void forcestop(); + int config(int i, int w, QString m); + +private slots: +#ifdef Q_WS_MAEMO_5 + friend void GpsMaemo5_changed(LocationGPSDevice *device, GpsMaemo5 *gps); +#else + void gloc_reply(QNetworkReply *r); +#endif // Q_WS_MAEMO_5 + +private: + double latitude; + double longitude; + double accuracy; + int interval; + int wait; + QString method; + bool emitfix; + bool stopgps; +#ifdef Q_WS_MAEMO_5 + LocationGPSDControl *control; + LocationGPSDevice *device; +#else + QUrl urlloc; + QNetworkAccessManager *worker; +#endif // Q_WS_MAEMO_5 +}; + +#ifdef Q_WS_MAEMO_5 +void GpsMaemo5_changed(LocationGPSDevice *device, GpsMaemo5 *gps); +#endif // Q_WS_MAEMO_5 + +#endif // GPS_H diff --git a/qml/MainPage.qml b/qml/MainPage.qml new file mode 100644 index 0000000..17f9154 --- /dev/null +++ b/qml/MainPage.qml @@ -0,0 +1,238 @@ +import QtQuick 1.0 +import com.meego 1.0 + +Page { + id: mainPage + Column { + spacing: 16 + Row { + width: rootWindow.width + Button { + id: do_auth + width: rootWindow.width / 3 + text: "Auth" + enabled: false + onClicked: { + Qt.openUrlExternally(latitude.getUserAuthorization()) + } + } + Button { + id: do_start + width: rootWindow.width / 3 + text: "Start" + enabled: false + onClicked: { + do_start.enabled = false; + do_stop.enabled = true; + gps.startUpdates() + } + } + Button { + id: do_stop + width: rootWindow.width / 3 + text: "Stop" + enabled: false + onClicked: { + do_start.enabled = true; + do_stop.enabled = false; + gps.stopUpdates(true) + } + } + } + Row { + width: rootWindow.width + Label { + id: pos_label + text: "Position" + width: rootWindow.width / 4 + anchors.verticalCenter: position.verticalCenter + } + Row { + id: position + width: rootWindow.width * 3 / 4 + TextField { + id: pos_lat + width: parent / 4 + placeholderText: "pos_lat" + readOnly: true + } + TextField { + id: pos_lon + width: parent / 4 + placeholderText: "pos_lon" + readOnly: true + } + TextField { + id: pos_acc + width: parent / 4 + placeholderText: "pos_acc" + readOnly: true + } + TextField { + id: pos_tis + width: parent / 4 + placeholderText: "pos_tis" + readOnly: true + } + } + } + Row { + Label { + id: method_label + text: "Method" + width: rootWindow.width / 4 + anchors.verticalCenter: method_button.verticalCenter + } + ButtonRow { + id: method_button + width: rootWindow.width * 2 / 3 + Button { + id: method_cell + text: "Cell Tower" + checked: gps.getPositioningMethod() == "cell" ? true : false + onClicked: gps.setPositioningMethod("cell") + } + Button { + id: method_all + text: "Both" + checked: gps.getPositioningMethod() == "all" ? true : false + onClicked: gps.setPositioningMethod("all") + } + Button { + id: method_agps + text: "Only GPS" + checked: gps.getPositioningMethod() == "gps" ? true : false + onClicked: gps.setPositioningMethod("gps") + } + } + } + Row { + Label { + id: timeout_label + text: "Time Out" + width: rootWindow.width / 4 + anchors.verticalCenter: timeout_slider.verticalCenter + } + Slider { + id: timeout_slider + width: rootWindow.width / 2 + valueIndicatorVisible: true + minimumValue: 5 + maximumValue: 120 + stepSize: 5 + value: gps.getTimeOut() + } + Label { + id: timeout_value + text: timeout_slider.value + " seg." + width: rootWindow.width / 4 + anchors.verticalCenter: timeout_slider.verticalCenter + } + Connections { + target: timeout_slider + onValueChanged: { + timeout_value.text = timeout_slider.value + " seg." + gps.setTimeOut(timeout_slider.value) + } + } + } + Row { + Label { + id: interval_label + text: "Interval" + width: rootWindow.width / 4 + anchors.verticalCenter: interval_slider.verticalCenter + } + Slider { + id: interval_slider + width: rootWindow.width / 2 + valueIndicatorVisible: true + minimumValue: 5 + maximumValue: 60 + stepSize: 5 + value: gps.getInterval() / 60 + } + Label { + id: interval_value + text: interval_slider.value + " min." + width: rootWindow.width / 4 + anchors.verticalCenter: interval_slider.verticalCenter + } + Connections { + target: interval_slider + onValueChanged: { + interval_value.text = interval_slider.value + " min." + gps.setInterval(interval_slider.value*60) + } + } + } + Row { + Label { + id: connect_label + text: "Auto Connect" + width: rootWindow.width / 4 + anchors.verticalCenter: connect_switch.verticalCenter + } + Switch { + id: connect_switch + width: rootWindow.width / 2 + checked: latitude.getAutoConnect() ? true : false + onCheckedChanged: { + connect_value.text = checked + latitude.setAutoConnect(checked) + } + } + Label { + id: connect_value + text: connect_switch.checked + width: rootWindow.width / 4 + anchors.verticalCenter: connect_switch.verticalCenter + } + } + + Connections { + target: latitude + onGotToken: { + do_auth.enabled = false; + do_start.enabled = true; + do_stop.enabled = false; + } + } + Connections { + target: latitude + onNotToken: { + do_auth.enabled = true; + do_start.enabled = false; + do_stop.enabled = false; + gps.stopUpdates(true) + } + } + Connections { + target: latitude + onNeedAuth: { + do_auth.enabled = true; + } + } + + Connections { + target: gps + onGotUpdate: { + pos_lat.text = gps.getCurrentLatitude() + pos_lon.text = gps.getCurrentLongitude() + pos_acc.text = gps.getCurrentAccuracy() + pos_tis.text = gps.getCurrentTimestamp() + } + } + Connections { + target: gps + onGotFix: { + pos_lat.text = gps.getCurrentLatitude() + pos_lon.text = gps.getCurrentLongitude() + pos_acc.text = gps.getCurrentAccuracy() + pos_tis.text = gps.getCurrentTimestamp() + latitude.setCurrentLocation(pos_lat.text, pos_lon.text, pos_acc.text) + latitude.sendCurrentLocation() + } + } + } +} diff --git a/qml/main.qml b/qml/main.qml new file mode 100644 index 0000000..b77d0f9 --- /dev/null +++ b/qml/main.qml @@ -0,0 +1,12 @@ +import QtQuick 1.0 +import com.meego 1.0 + +PageStackWindow { + id: rootWindow + initialPage: mainPage + MainPage { + id: mainPage + } + showStatusBar: false + showToolBar: false +} diff --git a/qtc_packaging/debian_fremantle/README b/qtc_packaging/debian_fremantle/README new file mode 100644 index 0000000..e407bf5 --- /dev/null +++ b/qtc_packaging/debian_fremantle/README @@ -0,0 +1,10 @@ +The Debian Package latitudeupdater +---------------------------- + +Comments regarding the Package + + -- Rodrigo Linfati sab, 02 gen 2010 22:12:52 +0100 + +Thanks to: + Joppu http://talk.maemo.org/member.php?u=24013 + http://talk.maemo.org/showpost.php?p=449435&postcount=83 diff --git a/qtc_packaging/debian_fremantle/changelog b/qtc_packaging/debian_fremantle/changelog new file mode 100644 index 0000000..7423439 --- /dev/null +++ b/qtc_packaging/debian_fremantle/changelog @@ -0,0 +1,5 @@ +latitudeupdater (0.1-0) unstable; urgency=low + + * Initial Release. + + -- Rodrigo Linfati Thu, 21 Jul 2011 21:58:20 +0200 diff --git a/qtc_packaging/debian_fremantle/compat b/qtc_packaging/debian_fremantle/compat new file mode 100644 index 0000000..7f8f011 --- /dev/null +++ b/qtc_packaging/debian_fremantle/compat @@ -0,0 +1 @@ +7 diff --git a/qtc_packaging/debian_fremantle/control b/qtc_packaging/debian_fremantle/control new file mode 100644 index 0000000..f56e759 --- /dev/null +++ b/qtc_packaging/debian_fremantle/control @@ -0,0 +1,20 @@ +Source: latitudeupdater +Section: user/navigation +Priority: optional +Maintainer: Rodrigo Linfati +Build-Depends: debhelper (>= 5), libqt4-dev, libqtm-dev +Standards-Version: 3.7.3 +Homepage: http://googlelatitude.garage.maemo.org/ +XSBC-Bugtracker: mailto:rodrigo@linfati.cl + +Package: latitudeupdater +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: Google Latitude Updater + Google Latitude Updater is written in QT4. + Features: + - Retrieve location using Cell Tower and/or Gps and send to Google Latitude + - Run as Daemon +XB-Maemo-Display-Name: LatitudeUpdater +XB-Maemo-Icon-26: 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 + diff --git a/qtc_packaging/debian_fremantle/copyright b/qtc_packaging/debian_fremantle/copyright new file mode 100644 index 0000000..73b9a6b --- /dev/null +++ b/qtc_packaging/debian_fremantle/copyright @@ -0,0 +1,34 @@ +This package was debianized by Rodrigo Linfati on +sab, 02 gen 2010 22:12:52 +0100. + +It was downloaded from + +Upstream Author(s): + + Rodrigo Linfati + +Copyright: + + Copyright (C) 2009 Rodrigo Linfati + +License: + + This package is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This package 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this package; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +On Debian systems, the complete text of the GNU Lesser General +Public License can be found in `/usr/share/common-licenses/LGPL'. + +The Debian packaging is (C) 2010, Rodrigo Linfati and +is licensed under the GPL, see `/usr/share/common-licenses/GPL'. diff --git a/qtc_packaging/debian_fremantle/rules b/qtc_packaging/debian_fremantle/rules new file mode 100755 index 0000000..501d645 --- /dev/null +++ b/qtc_packaging/debian_fremantle/rules @@ -0,0 +1,91 @@ +#!/usr/bin/make -f +# -*- makefile -*- +# Sample debian/rules that uses debhelper. +# This file was originally written by Joey Hess and Craig Small. +# As a special exception, when this file is copied by dh-make into a +# dh-make output file, you may use that output file without restriction. +# This special exception was added by Craig Small in version 0.37 of dh-make. + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + + + + + +configure: configure-stamp +configure-stamp: + dh_testdir + # qmake PREFIX=/usr# Uncomment this line for use without Qt Creator + + touch configure-stamp + + +build: build-stamp + +build-stamp: configure-stamp + dh_testdir + + # Add here commands to compile the package. + # $(MAKE) # Uncomment this line for use without Qt Creator + #docbook-to-man debian/latitudeupdater.sgml > latitudeupdater.1 + + touch $@ + +clean: + dh_testdir + dh_testroot + rm -f build-stamp configure-stamp + + # Add here commands to clean up after the build process. + $(MAKE) clean + + dh_clean + +install: build + dh_testdir + dh_testroot + dh_clean -k + dh_installdirs + + # Add here commands to install the package into debian/latitudeupdater. + $(MAKE) INSTALL_ROOT="$(CURDIR)"/debian/latitudeupdater install + + +# Build architecture-independent files here. +binary-indep: build install +# We have nothing to do by default. + +# Build architecture-dependent files here. +binary-arch: build install + dh_testdir + dh_testroot + dh_installchangelogs + dh_installdocs + dh_installexamples +# dh_install +# dh_installmenu +# dh_installdebconf +# dh_installlogrotate +# dh_installemacsen +# dh_installpam +# dh_installmime +# dh_python +# dh_installinit +# dh_installcron +# dh_installinfo + dh_installman + dh_link + dh_strip + dh_compress + dh_fixperms +# dh_perl +# dh_makeshlibs + dh_installdeb + # dh_shlibdeps # Uncomment this line for use without Qt Creator + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch +.PHONY: build clean binary-indep binary-arch binary install configure diff --git a/qtc_packaging/debian_harmattan/README b/qtc_packaging/debian_harmattan/README new file mode 100644 index 0000000..56bc3c9 --- /dev/null +++ b/qtc_packaging/debian_harmattan/README @@ -0,0 +1,10 @@ +The Debian Package latitudeupdater +---------------------------- + +Comments regarding the Package + + -- Rodrigo Linfati sab, 02 gen 2010 22:12:52 +0100 + +Thanks to: + Joppu http://talk.maemo.org/member.php?u=24013 + http://talk.maemo.org/showpost.php?p=449435&postcount=83 diff --git a/qtc_packaging/debian_harmattan/changelog b/qtc_packaging/debian_harmattan/changelog new file mode 100644 index 0000000..7423439 --- /dev/null +++ b/qtc_packaging/debian_harmattan/changelog @@ -0,0 +1,5 @@ +latitudeupdater (0.1-0) unstable; urgency=low + + * Initial Release. + + -- Rodrigo Linfati Thu, 21 Jul 2011 21:58:20 +0200 diff --git a/qtc_packaging/debian_harmattan/compat b/qtc_packaging/debian_harmattan/compat new file mode 100644 index 0000000..7f8f011 --- /dev/null +++ b/qtc_packaging/debian_harmattan/compat @@ -0,0 +1 @@ +7 diff --git a/qtc_packaging/debian_harmattan/control b/qtc_packaging/debian_harmattan/control new file mode 100644 index 0000000..709b8e9 --- /dev/null +++ b/qtc_packaging/debian_harmattan/control @@ -0,0 +1,20 @@ +Source: latitudeupdater +Section: user/navigation +Priority: optional +Maintainer: Rodrigo Linfati +Build-Depends: debhelper (>= 5), libqt4-dev, libqtm-dev +Standards-Version: 3.7.3 +Homepage: http://googlelatitude.garage.maemo.org/ +XSBC-Bugtracker: mailto:rodrigo@linfati.cl + +Package: latitudeupdater +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: Google Latitude Updater + Google Latitude Updater is written in QT4. + Features: + - Retrieve location using Cell Tower and/or Gps and send to Google Latitude + - Run as Daemon +XSBC-Maemo-Display-Name: LatitudeUpdater +XB-Maemo-Icon-26: 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 + diff --git a/qtc_packaging/debian_harmattan/copyright b/qtc_packaging/debian_harmattan/copyright new file mode 100644 index 0000000..73b9a6b --- /dev/null +++ b/qtc_packaging/debian_harmattan/copyright @@ -0,0 +1,34 @@ +This package was debianized by Rodrigo Linfati on +sab, 02 gen 2010 22:12:52 +0100. + +It was downloaded from + +Upstream Author(s): + + Rodrigo Linfati + +Copyright: + + Copyright (C) 2009 Rodrigo Linfati + +License: + + This package is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This package 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this package; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +On Debian systems, the complete text of the GNU Lesser General +Public License can be found in `/usr/share/common-licenses/LGPL'. + +The Debian packaging is (C) 2010, Rodrigo Linfati and +is licensed under the GPL, see `/usr/share/common-licenses/GPL'. diff --git a/qtc_packaging/debian_harmattan/rules b/qtc_packaging/debian_harmattan/rules new file mode 100755 index 0000000..501d645 --- /dev/null +++ b/qtc_packaging/debian_harmattan/rules @@ -0,0 +1,91 @@ +#!/usr/bin/make -f +# -*- makefile -*- +# Sample debian/rules that uses debhelper. +# This file was originally written by Joey Hess and Craig Small. +# As a special exception, when this file is copied by dh-make into a +# dh-make output file, you may use that output file without restriction. +# This special exception was added by Craig Small in version 0.37 of dh-make. + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + + + + + +configure: configure-stamp +configure-stamp: + dh_testdir + # qmake PREFIX=/usr# Uncomment this line for use without Qt Creator + + touch configure-stamp + + +build: build-stamp + +build-stamp: configure-stamp + dh_testdir + + # Add here commands to compile the package. + # $(MAKE) # Uncomment this line for use without Qt Creator + #docbook-to-man debian/latitudeupdater.sgml > latitudeupdater.1 + + touch $@ + +clean: + dh_testdir + dh_testroot + rm -f build-stamp configure-stamp + + # Add here commands to clean up after the build process. + $(MAKE) clean + + dh_clean + +install: build + dh_testdir + dh_testroot + dh_clean -k + dh_installdirs + + # Add here commands to install the package into debian/latitudeupdater. + $(MAKE) INSTALL_ROOT="$(CURDIR)"/debian/latitudeupdater install + + +# Build architecture-independent files here. +binary-indep: build install +# We have nothing to do by default. + +# Build architecture-dependent files here. +binary-arch: build install + dh_testdir + dh_testroot + dh_installchangelogs + dh_installdocs + dh_installexamples +# dh_install +# dh_installmenu +# dh_installdebconf +# dh_installlogrotate +# dh_installemacsen +# dh_installpam +# dh_installmime +# dh_python +# dh_installinit +# dh_installcron +# dh_installinfo + dh_installman + dh_link + dh_strip + dh_compress + dh_fixperms +# dh_perl +# dh_makeshlibs + dh_installdeb + # dh_shlibdeps # Uncomment this line for use without Qt Creator + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch +.PHONY: build clean binary-indep binary-arch binary install configure diff --git a/resouses.qrc b/resouses.qrc new file mode 100644 index 0000000..3d7ed28 --- /dev/null +++ b/resouses.qrc @@ -0,0 +1,6 @@ + + + qml/main.qml + qml/MainPage.qml + + -- 1.7.9.5