Version 0.001

v0.001/source-android/common/friendiqa.cpp

@@ -0,0 +1,19 @@
+#include <QApplication>
+#include <QtQml/QQmlEngine>
+#include <QtQuick>
+#include "xhr.h"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+    QQuickView view;
+
+
+    XHR* xhr = XHR::instance();
+    view.rootContext()->setContextProperty("xhr", xhr);
+     view.setSource(QUrl("qrc:/qml/friendiqa.qml"));
+    view.show();
+    view.connect(view.rootContext()->engine(), SIGNAL(quit()), &app, SLOT(quit()));
+    return app.exec();
+
+}
+

v0.001/source-android/common/uploadableimage.cpp

@@ -0,0 +1,90 @@
+#include "uploadableimage.h"
+
+
+#include <QBuffer>
+#include <QDebug>
+#include <QFileInfo>
+#include <QUrl>
+
+void UploadableImage::setSource(const QString &a) {
+    if (a != m_source) {
+        m_source = a;
+        //m_base64 = "";
+        m_mimetype = "";
+        m_filename = "";
+
+        qDebug() << "UploadableImage::setSource : " << m_source;
+
+        if (m_source=="") {
+            emit sourceChanged();
+            //emit base64Changed();
+            emit mimetypeChanged();
+            emit filenameChanged();
+            return;
+        }
+
+        QImage fullimage = QImage(QUrl(m_source).toLocalFile());
+        if (fullimage.width() > 800 || fullimage.height() > 800) {
+            if (fullimage.width() > fullimage.height()) {
+                m_image = fullimage.scaledToWidth(800);
+            } else {
+                m_image = fullimage.scaledToHeight(800);
+            }
+        } else {
+            m_image = fullimage;
+        }
+        qDebug() << "UploadableImage::setSource : " << m_image.width() << "x" << m_image.height();
+        emit sourceChanged();
+
+        QFileInfo fi(m_source);
+
+        m_filename = fi.fileName();
+        emit filenameChanged();
+
+        QString filetype = fi.suffix().toUpper();
+        if (filetype!="PNG" && filetype!="JPG") {
+            filetype = "JPG";
+        }
+        qDebug() << "UploadableImage::setSource : " << "Saving as " << filetype;
+
+        m_mimetype = "image/"+filetype.toLower();
+        emit mimetypeChanged();
+
+        /*
+        QByteArray byteArray;
+        QBuffer buffer(&byteArray);
+        m_image.save(&buffer, filetype.toLatin1().constData());
+        QString b64 = QString::fromLatin1(byteArray.toBase64().data());
+
+        for(int k=0; k<b64.length(); k+=76) {
+            m_base64 += b64.mid(k,76) + "\n";
+        }
+        m_base64 = m_base64.trimmed();
+
+        emit base64Changed();
+        */
+    }
+}
+
+QString UploadableImage::source() const {
+    return m_source;
+}
+
+//QString UploadableImage::base64() const {
+//    return m_base64;
+//}
+
+QString UploadableImage::filename() const {
+    return m_filename;
+}
+
+QString UploadableImage::mimetype() const {
+    return m_mimetype;
+}
+
+QByteArray UploadableImage::bytes() {
+    QByteArray byteArray;
+    QBuffer buffer(&byteArray);
+    m_image.save(&buffer, "PNG");
+    return byteArray;
+}

v0.001/source-android/common/uploadableimage.h

@@ -0,0 +1,40 @@
+#ifndef UPLOADABLEIMAGE_H
+#define UPLOADABLEIMAGE_H
+
+#include <QObject>
+#include <QQuickItem>
+#include <QImage>
+
+class UploadableImage : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)
+    //Q_PROPERTY(QString base64 READ base64 NOTIFY base64Changed)
+    Q_PROPERTY(QString filename READ filename NOTIFY filenameChanged)
+    Q_PROPERTY(QString mimetype READ mimetype NOTIFY mimetypeChanged)
+    Q_PROPERTY(QByteArray bytes READ bytes)
+
+public:
+    void setSource(const QString &a);
+    QString source() const;
+
+    //QString base64() const;
+    QString filename() const;
+    QString mimetype() const;
+
+    QByteArray bytes();
+signals:
+    void sourceChanged();
+    //void base64Changed();
+    void filenameChanged();
+    void mimetypeChanged();
+
+private:
+    QString m_source;
+    QImage m_image;
+    //QString m_base64;
+    QString m_filename;
+    QString m_mimetype;
+};
+
+#endif // UPLOADABLEIMAGE_H

v0.001/source-android/common/xhr.cpp

@@ -0,0 +1,168 @@
+#include "xhr.h"
+
+#include <QHttpPart>
+#include <QTextCodec>
+#include <QUrlQuery>
+
+#include "uploadableimage.h"
+
+XHR *XHR::instance()
+{
+    static XHR xhr;
+    return &xhr;
+}
+
+XHR::XHR(QObject *parent) : QObject(parent)
+{
+    request.setSslConfiguration(QSslConfiguration::defaultConfiguration());
+}
+
+void XHR::setUrl(QString url)
+{
+   if (url!=m_url) {
+       m_url = url;
+       emit urlChanged();
+   }
+}
+
+void XHR::setLogin(QString login)
+{
+   if (login!=m_login) {
+       m_login = login;
+       emit loginChanged();
+   }
+}
+QString XHR::url() const
+{
+    return m_url;
+}
+
+QString XHR::login() const
+{
+    return m_login;
+}
+
+void XHR::setParam(QString name, QString value)
+{
+    params.insert(name, value);
+}
+
+void XHR::setImageFileParam(QString name, QString url)
+{
+    files.insert(name, url);
+}
+
+void XHR::clearParams()
+{
+    files.clear();
+    params.clear();
+}
+
+void XHR::get()
+{
+    QUrlQuery query;
+
+    QHashIterator<QString, QString> i(params);
+    while(i.hasNext()) {
+        i.next();
+        query.addQueryItem(i.key(), i.value());
+    }
+
+    QUrl requrl(m_url);
+    requrl.setQuery(query);
+
+    QByteArray loginData = m_login.toLocal8Bit().toBase64();
+    QString headerData = "Basic " + loginData;
+    request.setRawHeader("Authorization", headerData.toLocal8Bit());
+
+
+    request.setUrl(requrl);
+    reply = manager.get(request);
+
+    connect(reply, &QNetworkReply::finished, this, &XHR::onReplySuccess);
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyError(QNetworkReply::NetworkError)));
+    connect(reply, &QNetworkReply::readyRead, this, &XHR::onReadyRead);
+
+}
+
+void XHR::post()
+{
+    qDebug() << "start post to " << m_url;
+    QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
+
+    QHashIterator<QString, QString> iparams(params);
+    while(iparams.hasNext()) {
+        iparams.next();
+        qDebug() << "\t add param " << iparams.key() << " : " << iparams.value();
+        QHttpPart textPart;
+        textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"" + iparams.key() + "\""));
+
+
+        textPart.setBody(iparams.value().toUtf8());
+        multiPart->append(textPart);
+    }
+
+    UploadableImage uimg;
+    QHashIterator<QString, QString> ifiles(files);
+    while(ifiles.hasNext()) {
+        ifiles.next();
+
+        uimg.setSource(ifiles.value());
+        qDebug() << "\t image: " << uimg.mimetype() << ", " << ifiles.key();
+
+        QHttpPart imagePart;
+        imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(uimg.mimetype()));
+        imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"" + ifiles.key() + "\"; filename=\""+uimg.filename()+"\""));
+        imagePart.setBody(uimg.bytes());
+        multiPart->append(imagePart);
+    }
+
+    QByteArray loginData = m_login.toLocal8Bit().toBase64();
+    QString headerData = "Basic " + loginData;
+    request.setRawHeader(QByteArray("Authorization"), headerData.toLocal8Bit());
+
+    request.setUrl(m_url);
+    reply = manager.post(request, multiPart);
+    qDebug() << "\t request sent";
+    connect(reply, &QNetworkReply::finished, this, &XHR::onReplySuccess);
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyError(QNetworkReply::NetworkError)));
+    connect(reply, &QNetworkReply::readyRead, this, &XHR::onReadyRead);
+    connect(reply, &QNetworkReply::sslErrors, this, &XHR::onSSLError);
+    qDebug() << "\t reply signals connected";
+}
+
+void XHR::onReplyError(QNetworkReply::NetworkError code)
+{
+    qDebug() << code;
+    emit this->error( bufferToString(), (int) code);
+    reply->deleteLater();
+}
+
+void XHR::onReplySuccess()
+{
+    qDebug() << "!";
+    emit this->success( bufferToString() );
+    reply->deleteLater();
+}
+
+void XHR::onReadyRead()
+{
+    qDebug() << ".";
+    buffer += reply->readAll();
+}
+
+void XHR::onSSLError(const QList<QSslError> &errors)
+{
+    qDebug() << "XHR::onSSLError :" ;
+    QListIterator<QSslError> ierrs(errors);
+    while(ierrs.hasNext()) {
+        qDebug() << "\t" <<  ierrs.next().errorString();
+    }
+}
+
+QString XHR::bufferToString()
+{
+    return QTextCodec::codecForName("utf-8")->toUnicode(buffer);
+}
+
+

v0.001/source-android/common/xhr.h

@@ -0,0 +1,60 @@
+#ifndef XHR_H
+#define XHR_H
+
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QObject>
+
+class XHR : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString url READ url WRITE setUrl NOTIFY urlChanged)
+    Q_PROPERTY(QString login READ login WRITE setLogin NOTIFY loginChanged)
+
+public:
+    static XHR *instance();
+
+    explicit XHR(QObject *parent = 0);
+
+    void setUrl(QString url);
+ //   void setLogin(QString login);
+    
+    QString url() const;
+    QString login() const;
+
+signals:
+    void urlChanged();
+    void loginChanged();
+    void success(QString data);
+    void error(QString data, int code);
+
+public slots:
+    void setLogin(QString login);
+    void setParam(QString name, QString value);
+    void setImageFileParam(QString name, QString url);
+    void clearParams();
+    void post();
+    void get();
+
+private slots:
+    void onReplyError(QNetworkReply::NetworkError code);
+    void onReplySuccess();
+    void onReadyRead();
+    void onSSLError(const QList<QSslError> &errors);
+
+private:
+    QByteArray buffer;
+    QString m_url;
+    QString m_login;
+    QHash<QString, QString> params;
+    QHash<QString, QString> files;
+
+    QNetworkAccessManager manager;
+    QNetworkRequest request;
+    QNetworkReply *reply;
+
+    QString bufferToString();
+};
+
+#endif // XHR_H