ADD_SUBDIRECTORY(o2)

*CMakeLists.txt.user

_build/

cmake_minimum_required(VERSION 2.8.11)

add_subdirectory(src)

if(BUILD_EXAMPLES)

  add_subdirectory(examples)

endif(BUILD_EXAMPLES)

Copyright (c) 2012, Akos Polster

All rights reserved.

Redistribution and use in source and binary forms, with or without 

modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice, this

list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice, 

this list of conditions and the following disclaimer in the documentation 

and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# OAuth 1.0 and 2.0 for Qt

This library encapsulates the OAuth 1.0 and 2.0 client authentication flows, and the sending of authenticated HTTP requests.

The primary target is Qt Quick applications on mobile devices.

## Contents

Class | Header | Purpose

:-- | :-- | :--

O1 | o1.h | Generic OAuth 1.0 authentication

O1RequestParameter | o1.h | An extra request parameter participating in request signing

O1Dropbox | o1dropbox.h | Dropbox OAuth specializations

O1Flickr | o1flickr.h | Flickr OAuth specializations

O1Requestor | o1requestor.h | Makes authenticated OAuth 1.0 requests: GET, POST or PUT, handles timeouts

O1Twitter | o1twitter.h | Twitter OAuth specializations

OXTwitter | oxtwitter.h | Twitter XAuth specialization

O2 | o2.h | Generic OAuth 2.0 authentication

O2Facebook | o2facebook.h | Facebook OAuth specialization

O2Gft | o2gft.h | Google Fusion Tables OAuth specialization

O2Reply | o2reply.h | A network request/reply that can time out

O2ReplyServer | o2replyserver.h | HTTP server to process authentication responses

O2Requestor | o2requestor.h | Makes authenticated OAuth 2.0 requests (GET, POST or PUT), handles timeouts and token expiry

O2Skydrive | o2skydrive.h | Skydrive OAuth specialization

SimpleCrypt | simplecrypt.h | Simple encryption and decryption by Andre Somers

O2AbstractStore | o2abstractstore.h | Base class for implemnting persistent stores

O2SettingsStore | o2settingsstore.h | A QSettings based persistent store for writing OAuth tokens

## Installation

Clone the Github repository, then add all files to your Qt project.

## Basic Usage

This example assumes a hypothetical Twitter client that will post tweets. Twitter is using OAuth 1.0.

### Setup

Include the required header files, and have some member variables that will be used for authentication and sending requests:

    #include "o1twitter.h"

    #include "o1requestor.h"

    O1Twitter *o1;

### Initialization

Instantiate one of the authenticator classes, like O1Twitter, set your application ID and application secret, and install the signal handlers:

    o1 = new O1Twitter(this);

    o1->setClientId(MY_CLIENT_ID);

    o1->setClientSecret(MY_CLIENT_SECRET);

    connect(o1, SIGNAL(linkedChanged()), this, SLOT(onLinkedChanged()));

    connect(o1, SIGNAL(linkingFailed()), this, SLOT(onLinkingFailed()));

    connect(o1, SIGNAL(linkingSucceeded()), this, SLOT(onLinkingSucceeded()));

    connect(o1, SIGNAL(openBrowser(QUrl)), this, SLOT(onOpenBrowser(QUrl)));

    connect(o1, SIGNAL(closeBrowser()), this, SLOT(onCloseBrowser()));

**Note:** For browserless Twitter authentication, you can use the OXTwitter specialized class which can do Twitter XAuth. You will need to additionally provide your Twitter login credentials (username & password) before calling *link()*.

### Handling Signals

O2 is an asynchronous library. It will send signals at various stages of authentication and request processing.

To handle these signals, implement the following slots in your code:

    void onLinkedChanged() {

        // Linking (login) state has changed.

        // Use o1->linked() to get the actual state

    }

    void onLinkingFailed() {

        // Login has failed

    }

    void onLinkingSucceeded() {

        // Login has succeeded

    }

    void onOpenBrowser(const QUrl *url) {

        // Open a web browser or a web view with the given URL.

        // The user will interact with this browser window to

        // enter login name, password, and authorize your application

        // to access the Twitter account

    }

    void onCloseBrowser() {

        // Close the browser window opened in openBrowser()

    }

### Logging In

To log in (or, to be more accurate, to link your application to the OAuth service), call the link() method:

    o1->link();

This initiates the authentication sequence. Your signal handlers above will be called at various stages. Lastly, if linking succeeds, onLinkingSucceeded() will be called.

### Logging Out

To log out, call the unlink() method:

    o1->unlink();

Logging out always succeeds, and requires no user interaction.

### Sending Authenticated Requests

Once linked, you can start sending authenticated requests to the service. We start with a simple example of sending a text-only tweet or as it's known in Twitter docs, a 'status update'.

First we need a Qt network manager and an O1 requestor object:

    QNetworkAccessManager* manager = new QNetworkAccessManager(this);

    O1Requestor* requestor = new O1Requestor(manager, o1, this);

Next, create parameters for posting the update:

    QByteArray paramName("status");

    QByteArray tweetText("My first tweet!");

    QList<O1RequestParameter> reqParams = QList<O1RequestParameter>();

    reqParams << O1RequestParameter(paramName, tweetText);

    QByteArray postData = O1::createQueryParams(reqParams);

    // Using Twitter's REST API ver 1.1

    QUrl url = QUrl("https://api.twitter.com/1.1/statuses/update.json");

    QNetworkRequest request(url);

    request.setHeader(QNetworkRequest::ContentTypeHeader, O2_MIME_TYPE_XFORM);

Finally we authenticate and send the request using the O1 requestor object:

    QNetworkReply *reply = requestor->post(request, reqParams, postData);

Continuing with the example, we will now send a tweet containing an image as well as a message.

We create an HTTP request containing the image and the message, in the format specified by Twitter:

    QString imagePath("/tmp/image.jpg");

    QString message("My tweet with an image!");

    QFileInfo fileInfo(imagePath);

    QFile file(imagePath);

    file.open(QIODevice::ReadOnly);

    QString boundary("7d44e178b0439");

    QByteArray data(QString("--" + boundary + "\r\n").toAscii());

    data += "Content-Disposition: form-data; name=\"media[]\"; filename=\"" + fileInfo.fileName() + "\"\r\n";

    data += "Content-Transfer-Encoding: binary\r\n";

    data += "Content-Type: application/octet-stream\r\n\r\n";

    data += file.readAll();

    file.close();

    data += QString("\r\n--") + boundary + "\r\n";

    data += "Content-Disposition: form-data; name=\"status\"\r\n";

    data += "Content-Transfer-Encoding: binary\r\n";

    data += "Content-Type: text/plain; charset=utf-8\r\n\r\n";

    data += message.toUtf8();

    data += QString("\r\n--") + boundary + "--\r\n";

    QNetworkRequest request;

    // Using Twitter's REST API ver 1.1

    static const char *uploadUrl = "https://api.twitter.com/1.1/statuses/update_with_media.json";

    request.setUrl(QUrl(uploadUrl));

    request.setHeader(QNetworkRequest::ContentTypeHeader, "multipart/form-data; boundary=" + boundary);

    request.setHeader(QNetworkRequest::ContentLengthHeader, data.length());

    QNetworkReply *reply = requestor->post(request, QList<O1RequestParameter>(), data);

That's it. Tweets using the O2 library!

### Storing OAuth Tokens

O2 provides simple storage classes for writing OAuth tokens in a peristent location. Currently, a QSettings based backing store **O2SettingsStore** is provided in O2. O2SettingsStore keeps all token values in an encrypted form. You have to specify the encryption key to use while constructing the object:

    O2SettingsStore settings = new O2SettingsStore("myencryptionkey");

    // Set the store before starting OAuth, i.e before calling link()

    o1->setStore(settings);

    ...

You can also create it with your customized QSettings object. O2SettingsStore will then use that QSettings object for storing the tokens:

    O2SettingsStore settings = new O2SettingsStore(mySettingsObject, "myencryptionkey");

Once set, O2SettingsStore takes ownership of the QSettings object.

**Note:** If you do not specify a storage object to use, O2 will create one by default (which QSettings based), and use it. In such a case, a default encryption key is used for encrypting the data.

### Extra OAuth Tokens

Some OAuth service providers provide additional information in the access token response. Eg: Twitter returns 2 additional tokens in it's access token response - *screen_name* and *user_id*.

O2 provides all such tokens via the property - *extraTokens*. You can query this property after a successful OAuth exchange, i.e after the *linkingSucceeded()* signal has been emitted.

# SimpleCrypt

Copyright (c) 2011, Andre Somers

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright

     notice, this list of conditions and the following disclaimer.

   * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

   * Neither the name of the Rathenau Instituut, Andre Somers nor the

     names of its contributors may be used to endorse or promote products

     derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL ANDRE SOMERS BE LIABLE FOR ANY

DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Contributions by Mandeep Sandhu <mandeepsandhu.chd@gmail.com>

"Hi Akos,

I'm writing this mail to confirm that my contributions to the O2 library, available here https://github.com/pipacs/o2, can be freely distributed according to the project's license (as shown in the LICENSE file).

Regards,

-mandeep"

*.pro.user

build*

*.o

*.moc

moc_*

Makefile

cmake_minimum_required(VERSION 2.8.11)

if(WITH_FACEBOOK)

    add_subdirectory(facebookdemo)

endif(WITH_FACEBOOK)

if(WITH_TWITTER)

    add_subdirectory(twitterdemo)

endif(WITH_TWITTER)

cmake_minimum_required(VERSION 2.8.11)

project( fbexample )

set(CMAKE_AUTOMOC ON)

set(CMAKE_INCLUDE_CURRENT_DIR ON)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

set(QT_USE_QTNETWORK true)

set(QT_USE_QTSCRIPT true)

find_package(Qt4 REQUIRED)

include( ${QT_USE_FILE} )

include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} "../../src" )

set(fb_SRCS

    main.cpp

    fbdemo.cpp

)

add_definitions(${QT4_DEFINITIONS})

add_executable( fbexample ${fb_SRCS} )

target_link_libraries( fbexample ${QT_LIBRARIES} o2 )

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4) {

    QT += widgets

}

include(../../src/src.pri)

TARGET = facebookdemo

TEMPLATE = app

SOURCES += main.cpp \

    fbdemo.cpp

HEADERS += \

    fbdemo.h

#include <QNetworkAccessManager>

#include <QNetworkRequest>

#include <QNetworkReply>

#include <QDesktopServices>

#include <QMetaEnum>

#include <QDebug>

#include "fbdemo.h"

#include "o2globals.h"

#include "o2settingsstore.h"

const char FB_APP_KEY[] = "227896037359072";

const char FB_APP_SECRET[] = "3d35b063872579cf7213e09e76b65ceb";

const char FB_REQUEST_URL[] = "https://www.facebook.com/dialog/oauth";

const char FB_TOKEN_URL[] = "https://graph.facebook.com/oauth/access_token";

const char FB_DEBUG_TOKEN[] = "https://graph.facebook.com/me?fields=id&access_token=%1";

const int localPort = 8888;

#define QENUM_NAME(o,e,v) \

    (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).\

    valueToKey((v)))

#define GRANTFLOW_STR(v) QString(QENUM_NAME(O2, \

    GrantFlow, v))

FBDemo::FBDemo(QObject *parent) :

    QObject(parent) {

    o2Facebook_ = new O2Facebook(this);

    o2Facebook_->setClientId(FB_APP_KEY);

    o2Facebook_->setClientSecret(FB_APP_SECRET);

    o2Facebook_->setLocalPort(localPort);

    o2Facebook_->setRequestUrl(FB_REQUEST_URL);

    o2Facebook_->setTokenUrl(FB_TOKEN_URL);

    // Create a store object for writing the received tokens

    O2SettingsStore *store = new O2SettingsStore(O2_ENCRYPTION_KEY);

    store->setGroupKey("facebook");

    o2Facebook_->setStore(store);

    connect(o2Facebook_, SIGNAL(linkedChanged()),

            this, SLOT(onLinkedChanged()));

    connect(o2Facebook_, SIGNAL(linkingFailed()),

            this, SIGNAL(linkingFailed()));

    connect(o2Facebook_, SIGNAL(linkingSucceeded()),

            this, SLOT(onLinkingSucceeded()));

    connect(o2Facebook_, SIGNAL(openBrowser(QUrl)),

            this, SLOT(onOpenBrowser(QUrl)));

    connect(o2Facebook_, SIGNAL(closeBrowser()),

            this, SLOT(onCloseBrowser()));

}

void FBDemo::doOAuth(O2::GrantFlow grantFlowType) {

    qDebug() << "Starting OAuth 2 with grant flow type"

             << GRANTFLOW_STR(grantFlowType) << "...";

    o2Facebook_->setGrantFlow(grantFlowType);

    o2Facebook_->link();

}

void FBDemo::validateToken() {

    if (!o2Facebook_->linked()) {

        qWarning() << "ERROR: Application is not linked!";

        emit linkingFailed();

        return;

    }

    QString accessToken = o2Facebook_->token();

    QString debugUrlStr = QString(FB_DEBUG_TOKEN).arg(accessToken);

    QNetworkRequest request = QNetworkRequest(QUrl(debugUrlStr));

    QNetworkAccessManager *mgr = new QNetworkAccessManager(this);

    QNetworkReply *reply = mgr->get(request);

    connect(reply, SIGNAL(finished()), this, SLOT(onFinished()));

    qDebug() << "Validating user token. Please wait...";

}

void FBDemo::onOpenBrowser(const QUrl &url) {

    QDesktopServices::openUrl(url);

}

void FBDemo::onCloseBrowser() {

}

void FBDemo::onLinkedChanged() {

    qDebug() << "Link changed!";

}

void FBDemo::onLinkingSucceeded() {

    O2Facebook* o1t = qobject_cast<O2Facebook *>(sender());

     QVariantMap extraTokens = o1t->extraTokens();

    if (!extraTokens.isEmpty()) {

        emit extraTokensReady(extraTokens);

        qDebug() << "Extra tokens in response:";

        foreach (QString key, extraTokens.keys()) {

            qDebug() << "\t" << key << ":" << extraTokens.value(key).toString();

        }

    }

    emit linkingSucceeded();

}

void FBDemo::onFinished() {

    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());

    if (!reply) {

        qWarning() << "NULL reply!";

        emit linkingFailed();

        return;

    }

    reply->deleteLater();

    if (reply->error() != QNetworkReply::NoError) {

        qWarning() << "Reply error:" << reply->error();

        qWarning() << "Reason:" << reply->errorString();

        emit linkingFailed();

        return;

    }

    QByteArray replyData = reply->readAll();

    bool valid = !replyData.contains("error");

    if (valid) {

        qDebug() << "Token is valid";

        emit linkingSucceeded();

    } else {

        qDebug() << "Token is invalid";

        emit linkingFailed();

    }

}

#ifndef FBDEMO_H

#define FBDEMO_H

#include <QObject>

#include "o2facebook.h"

class FBDemo : public QObject

{

    Q_OBJECT

public:

    explicit FBDemo(QObject *parent = 0);

signals:

    void extraTokensReady(const QVariantMap &extraTokens);

    void linkingFailed();

    void linkingSucceeded();

public slots:

    void doOAuth(O2::GrantFlow grantFlowType);

    void validateToken();

private slots:

    void onLinkedChanged();

    void onLinkingSucceeded();

    void onOpenBrowser(const QUrl &url);

    void onCloseBrowser();

    void onFinished();

private:

    O2Facebook *o2Facebook_;

};

#endif // FBDEMO_H

#include <QApplication>

#include <QStringList>

#include <QTimer>

#include <QDebug>

#include "fbdemo.h"

const char OPT_OAUTH_CODE[] = "-o";

const char OPT_VALIDATE_TOKEN[] = "-v";

const char USAGE[] = "\n"

                     "Usage: facebookdemo [OPTION]...\n"

                     "Get OAuth2 access tokens from Facebook's OAuth service\n"

                     "\nOptions:\n"

                     "  %1\t\tLink with Facebook OAuth2 service using Authorization Code\n"

                     "  %2\t\tValidate Access Token\n";

class Helper : public QObject

{

    Q_OBJECT

public:

    Helper() : QObject(), fbdemo_(this), waitForMsg_(false), msg_(QString()) {}

public slots:

    void processArgs() {

        QStringList argList = qApp->arguments();

        QByteArray help = QString(USAGE).arg(OPT_OAUTH_CODE,

                                             OPT_VALIDATE_TOKEN).toLatin1();

        const char* helpText = help.constData();

        connect(&fbdemo_, SIGNAL(linkingFailed()),

                this, SLOT(onLinkingFailed()));

        connect(&fbdemo_, SIGNAL(linkingSucceeded()),

                this, SLOT(onLinkingSucceeded()));

        if (argList.contains(OPT_OAUTH_CODE)) {

            // Start OAuth

            fbdemo_.doOAuth(O2::GrantFlowAuthorizationCode);

        } else if (argList.contains(OPT_VALIDATE_TOKEN)) {

            fbdemo_.validateToken();

        } else {

            qDebug() << helpText;

            qApp->exit(1);

        }

    }

    void onLinkingFailed() {

        qDebug() << "Linking failed!";

        qApp->exit(1);

    }

    void onLinkingSucceeded() {

        qDebug() << "Linking succeeded!";

        if (waitForMsg_) {

            //postStatusUpdate(msg_);

        } else {

            qApp->quit();

        }

    }

private:

    FBDemo fbdemo_;

    bool waitForMsg_;

    QString msg_;

};

int main(int argc, char *argv[])

{

    QApplication a(argc, argv);

    Helper helper;

    QTimer::singleShot(0, &helper, SLOT(processArgs()));

    return a.exec();

}

#include "main.moc"

cmake_minimum_required(VERSION 2.8.11)

project( twitterexample )

set(CMAKE_AUTOMOC ON)

set(CMAKE_INCLUDE_CURRENT_DIR ON)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

set(QT_USE_QTNETWORK true)

set(QT_USE_QTSCRIPT true)

find_package(Qt4 REQUIRED)

include( ${QT_USE_FILE} )

include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} "../../src" )

set(fb_SRCS

    main.cpp

    tweeter.cpp

)

add_definitions(${QT4_DEFINITIONS})

add_executable( twitterexample ${fb_SRCS} )

target_link_libraries( twitterexample ${QT_LIBRARIES} o2 )

#include <QApplication>

#include <QStringList>

#include <QTimer>

#include <QDebug>

#include "tweeter.h"

const char OPT_OAUTH[] = "-o";

const char OPT_XAUTH[] = "-x";

const char OPT_USERNAME[] = "-u";

const char OPT_PASSWORD[] = "-p";

const char OPT_STATUS[] = "-m";

const char USAGE[] = "\n"

                     "Usage: tweetdemo [OPTION]...\n"

                     "Get OAuth access tokens from Twitter's OAuth service and "

                     "(optionally) post a status update on a user's timeline\n"

                     "\nOptions:\n"

                     "  %1\t\tLink with Twitter OAuth service, i.e get access tokens\n"

                     "  %2\t\tLink with Twitter XAuth service, i.e get access tokens using the XAuth protocol\n"

                     "  %3 <username>\tTwitter username to be used while using XAuth (-x option)\n"

                     "  %4 <password>\tTwitter password to be used while using XAuth (-x option)\n"

                     "  %5\t\tStatus update message, enclosed in double quotes\n";

class Helper : public QObject

{

    Q_OBJECT

public:

    Helper() : QObject(), tweeter_(this), waitForMsg_(false), msg_(QString()) {}

public slots:

    void processArgs() {

        QStringList argList = qApp->arguments();

        QByteArray help = QString(USAGE).arg(OPT_OAUTH,

                                             OPT_XAUTH,

                                             OPT_USERNAME,

                                             OPT_PASSWORD,

                                             OPT_STATUS).toLatin1();

        const char* helpText = help.constData();

        connect(&tweeter_, SIGNAL(linkingFailed()),

                this, SLOT(onLinkingFailed()));

        connect(&tweeter_, SIGNAL(linkingSucceeded()),

                this, SLOT(onLinkingSucceeded()));

        if (argList.contains(OPT_OAUTH)) {

            if (argList.contains(OPT_STATUS)) {

                waitForMsg_ = true;

                msg_ = argList.at(argList.indexOf(OPT_STATUS) + 1);

            }

            // Start OAuth

            tweeter_.doOAuth();

        } else if (argList.contains(OPT_XAUTH)) {

            if (!(argList.contains(OPT_USERNAME) && argList.contains(OPT_PASSWORD))) {

                qDebug() << "\nError: Username or Password missing!";

                qDebug() << helpText;

                qApp->exit(1);

            }

            QString username = argList.at(argList.indexOf(OPT_USERNAME) + 1);

            QString password = argList.at(argList.indexOf(OPT_PASSWORD) + 1);

            if (argList.contains(OPT_STATUS)) {

                waitForMsg_ = true;

                msg_ = argList.at(argList.indexOf(OPT_STATUS) + 1);

            }

            // Start XAuth

            tweeter_.doXAuth(username, password);

        } else if (argList.contains(OPT_STATUS)) {

            QString statusMessage = argList.at(argList.indexOf(OPT_STATUS) + 1);

            postStatusUpdate(statusMessage);

        } else {

            qDebug() << helpText;

            qApp->exit(1);

        }

    }

    void onLinkingFailed() {

        qDebug() << "Linking failed!";

        qApp->exit(1);

    }

    void onLinkingSucceeded() {

        qDebug() << "Linking succeeded!";

        if (waitForMsg_) {

            postStatusUpdate(msg_);

        } else {

            qApp->quit();

        }

    }

private slots:

    void postStatusUpdate(const QString& msg) {

        connect(&tweeter_, SIGNAL(statusPosted()),

                qApp, SLOT(quit()));

        tweeter_.postStatusUpdate(msg);

    }

private:

    Tweeter tweeter_;

    bool waitForMsg_;

    QString msg_;

};

int main(int argc, char *argv[])

{

    QApplication a(argc, argv);

    Helper helper;

    QTimer::singleShot(0, &helper, SLOT(processArgs()));

    return a.exec();

}

#include "main.moc"

#include <QNetworkAccessManager>

#include <QNetworkRequest>

#include <QDesktopServices>

#include <QDebug>

#include "tweeter.h"

#include "o2globals.h"

#include "o1requestor.h"

#include "o2settingsstore.h"

const char O2_CONSUMER_KEY[] = "2vHeyIxjywIadjEhvbDpg";

const char O2_CONSUMER_SECRET[] = "Xfwe195Kp3ZpcCKgkYs7RKfugTm8EfpLkQvsKfX2vvs";

const int localPort = 8888;

Tweeter::Tweeter(QObject *parent) :

    QObject(parent) {

}

void Tweeter::doOAuth() {

    o1Twitter_ = new O1Twitter(this);

    o1Twitter_->setClientId(O2_CONSUMER_KEY);

    o1Twitter_->setClientSecret(O2_CONSUMER_SECRET);

    o1Twitter_->setLocalPort(localPort);

    // Create a store object for writing the received tokens

    O2SettingsStore *store = new O2SettingsStore(O2_ENCRYPTION_KEY);

    store->setGroupKey("twitter");

    o1Twitter_->setStore(store);

    // Connect signals

    connect(o1Twitter_, SIGNAL(linkedChanged()),

            this, SLOT(onLinkedChanged()));

    connect(o1Twitter_, SIGNAL(linkingFailed()),

            this, SIGNAL(linkingFailed()));

    connect(o1Twitter_, SIGNAL(linkingSucceeded()),

            this, SLOT(onLinkingSucceeded()));

    connect(o1Twitter_, SIGNAL(openBrowser(QUrl)),

            this, SLOT(onOpenBrowser(QUrl)));

    connect(o1Twitter_, SIGNAL(closeBrowser()),

            this, SLOT(onCloseBrowser()));

    qDebug() << "Starting OAuth...";

    o1Twitter_->link();

}

void Tweeter::doXAuth(const QString &username, const QString &password) {

    oxTwitter_ = new OXTwitter(this);

    oxTwitter_->setClientId(O2_CONSUMER_KEY);

    oxTwitter_->setClientSecret(O2_CONSUMER_SECRET);

    oxTwitter_->setLocalPort(localPort);

    oxTwitter_->setUsername(username);

    oxTwitter_->setPassword(password);

    // Create a store object for writing the received tokens

    O2SettingsStore *store = new O2SettingsStore(O2_ENCRYPTION_KEY);