v0.1

source-android/common/filesystem.cpp

@@ -54,6 +54,7 @@ void FILESYSTEM::makeDir(QString name)
 void FILESYSTEM::rmDir()
 {
     QDir dir(m_Directory);
+    //qDebug()<<m_Directory;
    if (dir.removeRecursively()){
     emit success(m_Directory);
     }
@@ -63,6 +64,8 @@ void FILESYSTEM::rmDir()
 void FILESYSTEM::rmFile(QString name)
 {
     QDir dir(m_Directory);
+    //qDebug()<<m_Directory;
+    //qDebug(name);
     if(dir.remove(name)){
     emit success(name);
     }
@@ -79,3 +82,47 @@ QFileInfoList FILESYSTEM::fileList()
     //qDebug() << "filelist " << m_Filelist;
     return dir.entryInfoList();
 }
+
+void FILESYSTEM::searchImage()
+{
+    QAndroidJniObject ACTION_PICK = QAndroidJniObject::getStaticObjectField("android/content/Intent", "ACTION_PICK", "Ljava/lang/String;");
+    QAndroidJniObject EXTERNAL_CONTENT_URI = QAndroidJniObject::getStaticObjectField("android/provider/MediaStore$Images$Media", "EXTERNAL_CONTENT_URI", "Landroid/net/Uri;");
+
+    QAndroidJniObject intent=QAndroidJniObject("android/content/Intent", "(Ljava/lang/String;Landroid/net/Uri;)V", ACTION_PICK.object<jstring>(), EXTERNAL_CONTENT_URI.object<jobject>());
+
+    if (ACTION_PICK.isValid() && intent.isValid())
+    {
+        intent.callObjectMethod("setType", "(Ljava/lang/String;)Landroid/content/Intent;", QAndroidJniObject::fromString("image/*").object<jstring>());
+        QtAndroid::startActivity(intent.object<jobject>(), 101,this);
+        qDebug() << "OK";
+    }
+    else
+    {
+        qDebug() << "ERRO";
+    }
+}
+
+void FILESYSTEM::handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data)
+{
+    jint RESULT_OK = QAndroidJniObject::getStaticField<jint>("android/app/Activity", "RESULT_OK");
+    if (receiverRequestCode == 101 && resultCode == RESULT_OK)
+    {
+        QAndroidJniObject uri = data.callObjectMethod("getData", "()Landroid/net/Uri;");
+        QAndroidJniObject dadosAndroid = QAndroidJniObject::getStaticObjectField("android/provider/MediaStore$MediaColumns", "DATA", "Ljava/lang/String;");
+        QAndroidJniEnvironment env;
+        jobjectArray projecao = (jobjectArray)env->NewObjectArray(1, env->FindClass("java/lang/String"), NULL);
+        jobject projacaoDadosAndroid = env->NewStringUTF(dadosAndroid.toString().toStdString().c_str());
+        env->SetObjectArrayElement(projecao, 0, projacaoDadosAndroid);
+        QAndroidJniObject contentResolver = QtAndroid::androidActivity().callObjectMethod("getContentResolver", "()Landroid/content/ContentResolver;");
+        QAndroidJniObject cursor = contentResolver.callObjectMethod("query", "(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;", uri.object<jobject>(), projecao, NULL, NULL, NULL);
+        jint columnIndex = cursor.callMethod<jint>("getColumnIndex", "(Ljava/lang/String;)I", dadosAndroid.object<jstring>());
+        cursor.callMethod<jboolean>("moveToFirst", "()Z");
+        QAndroidJniObject resultUri = cursor.callObjectMethod("getString", "(I)Ljava/lang/String;", columnIndex);
+        QString imageSelect = "file://" + resultUri.toString();
+        emit imageselected(imageSelect);
+    }
+    else
+    {
+        qDebug() << "Select error";
+    }
+}

source-android/common/filesystem.h

@@ -4,8 +4,9 @@
 #include <QDir>
 #include <QObject>
 #include <QtAndroidExtras>
+#include <QAndroidActivityResultReceiver>
 
-class FILESYSTEM : public QObject
+class FILESYSTEM : public QObject, public QAndroidActivityResultReceiver
 {
     Q_OBJECT
     Q_PROPERTY(QString Directory READ Directory WRITE setDirectory NOTIFY directoryChanged)
@@ -23,8 +24,10 @@ public:
     //bool direxist(QString Directory);
     QString homePath() const;
     QString cameraPath() const;
+    virtual void handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data);
 
 signals:
+    void imageselected(QString);
     void directoryChanged();
     //void fileListContent(QList data);
     void success(QString data);
@@ -34,6 +37,7 @@ public slots:
     void makeDir(QString name);
     void rmDir();
     void rmFile(QString name);
+    void searchImage();
     //void fileList();
 
 private:

source-android/common/friendiqa.cpp

@@ -3,6 +3,26 @@
 #include <QtQuick>
 #include "xhr.h"
 #include "filesystem.h"
+//#include "qadrawableprovider.h"
+//#include "androidnative.pri/cpp/AndroidNative/systemdispatcher.h"
+#include "AndroidNative/systemdispatcher.h"
+#include "AndroidNative/environment.h"
+#include "AndroidNative/debug.h"
+#include "AndroidNative/mediascannerconnection.h"
+//#include "debugwrapper.h"
+
+#ifdef Q_OS_ANDROID 
+#include <QtAndroidExtras/QAndroidJniObject> 
+#include <QtAndroidExtras/QAndroidJniEnvironment>
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
+    Q_UNUSED(vm);
+ qDebug("NativeInterface::JNI_OnLoad()"); // It must call this function within JNI_OnLoad to enable System Dispatcher
+
+ AndroidNative::SystemDispatcher::registerNatives();
+ return JNI_VERSION_1_6;
+ } 
+#endif
+
 
 int main(int argc, char *argv[]) {
     QApplication app(argc, argv);
@@ -11,6 +31,8 @@ int main(int argc, char *argv[]) {
     qtTranslator.load("friendiqa-" + QLocale::system().name(),":/translations");
     app.installTranslator(&qtTranslator);
 
+//    qmlRegisterType<QASystemDispatcher>("SystemDispatcher", 0, 1, "SystemDispatcher");
+
     XHR* xhr = XHR::instance();
     view.rootContext()->setContextProperty("xhr", xhr);
     FILESYSTEM* filesystem = FILESYSTEM::instance();

source-android/common/imageselectandroid.cpp

@@ -0,0 +1,56 @@
+#include "imageselectandroid.h"
+
+imageSelectAndroid::imageSelectAndroid()
+{
+
+}
+imageSelectAndroid *imageSelectAndroid::instance()
+{
+    static imageSelectAndroid imageselectandroid;
+    return &imageselectandroid;
+}
+
+void imageSelectAndroid::searchImage()
+{
+    QAndroidJniObject ACTION_PICK = QAndroidJniObject::getStaticObjectField("android/content/Intent", "ACTION_PICK", "Ljava/lang/String;");
+    QAndroidJniObject EXTERNAL_CONTENT_URI = QAndroidJniObject::getStaticObjectField("android/provider/MediaStore$Images$Media", "EXTERNAL_CONTENT_URI", "Landroid/net/Uri;");
+
+    QAndroidJniObject intent=QAndroidJniObject("android/content/Intent", "(Ljava/lang/String;Landroid/net/Uri;)V", ACTION_PICK.object<jstring>(), EXTERNAL_CONTENT_URI.object<jobject>());
+
+    if (ACTION_PICK.isValid() && intent.isValid())
+    {
+        intent.callObjectMethod("setType", "(Ljava/lang/String;)Landroid/content/Intent;", QAndroidJniObject::fromString("image/*").object<jstring>());
+        QtAndroid::startActivity(intent.object<jobject>(), 101, this);
+        qDebug() << "OK";
+    }
+    else
+    {
+        qDebug() << "ERRO";
+    }
+}
+
+void imageSelectAndroid::handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data)
+{               qDebug() << "done";
+    jint RESULT_OK = QAndroidJniObject::getStaticField<jint>("android/app/Activity", "RESULT_OK");
+    if (receiverRequestCode == 101 && resultCode == RESULT_OK)
+    {
+                qDebug() << "done";
+        QAndroidJniObject uri = data.callObjectMethod("getData", "()Landroid/net/Uri;");
+        QAndroidJniObject dadosAndroid = QAndroidJniObject::getStaticObjectField("android/provider/MediaStore$MediaColumns", "DATA", "Ljava/lang/String;");
+        QAndroidJniEnvironment env;
+        jobjectArray projecao = (jobjectArray)env->NewObjectArray(1, env->FindClass("java/lang/String"), NULL);
+        jobject projacaoDadosAndroid = env->NewStringUTF(dadosAndroid.toString().toStdString().c_str());
+        env->SetObjectArrayElement(projecao, 0, projacaoDadosAndroid);
+        QAndroidJniObject contentResolver = QtAndroid::androidActivity().callObjectMethod("getContentResolver", "()Landroid/content/ContentResolver;");
+        QAndroidJniObject cursor = contentResolver.callObjectMethod("query", "(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;", uri.object<jobject>(), projecao, NULL, NULL, NULL);
+        jint columnIndex = cursor.callMethod<jint>("getColumnIndex", "(Ljava/lang/String;)I", dadosAndroid.object<jstring>());
+        cursor.callMethod<jboolean>("moveToFirst", "()Z");
+        QAndroidJniObject resultUri = cursor.callObjectMethod("getString", "(I)Ljava/lang/String;", columnIndex);
+        QString imageSelect = "file://" + resultUri.toString();
+        emit imageselected(imageSelect);
+    }
+    else
+    {
+        qDebug() << "Select error";
+    }
+}

source-android/common/imageselectandroid.h

@@ -0,0 +1,23 @@
+#ifndef IMAGEPICKANDROID_H
+#define IMAGEPICKANDROID_H
+#include <QObject>
+#include <QtAndroidExtras>
+
+#include <QDebug>
+
+class imageSelectAndroid : public QObject, public QAndroidActivityResultReceiver
+{
+    Q_OBJECT
+
+public:
+    imageSelectAndroid();
+    static imageSelectAndroid *instance();
+    void searchImage();
+
+    virtual void handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject & data);
+
+signals:
+    void imageselected(QString);
+};
+
+#endif // IMAGEPICKANDROID_H

source-android/common/qasystemdispatcher.cpp

@@ -0,0 +1,348 @@
+// Author:  Ben Lau (https://github.com/benlau)
+#include <QCoreApplication>
+#include <QPointer>
+#include <QtCore>
+#include <QPair>
+#include <QQueue>
+#include "qasystemdispatcher.h"
+
+static QPointer<QASystemDispatcher> m_instance;
+
+QString QASystemDispatcher::ACTIVITY_RESUME_MESSAGE = "Activity.onResume";
+QString QASystemDispatcher::ACTIVITY_RESULT_MESSAGE = "Activity.onActivityResult";
+
+
+#ifdef Q_OS_ANDROID
+#include <QAndroidJniObject>
+#include <QAndroidJniEnvironment>
+
+#define JCLASS_Name "quickandroid/SystemDispatcher"
+#define DISPATCH_SIGNATURE "(Ljava/lang/String;Ljava/util/Map;)V"
+#define EMIT_SIGNATURE "(Ljava/lang/String;Ljava/util/Map;)V"
+
+static QVariantMap createVariantMap(jobject data);
+static jobject createHashMap(const QVariantMap &data);
+
+static QVariant convertToQVariant(QAndroidJniObject value) {
+    QVariant v;
+    if (!value.isValid()) {
+        return v;
+    }
+
+    QAndroidJniEnvironment env;
+
+    jclass jclass_of_string = env->FindClass("java/lang/String");
+    jclass jclass_of_integer = env->FindClass("java/lang/Integer");
+    jclass jclass_of_boolean = env->FindClass("java/lang/Boolean");
+    jclass jclass_of_list = env->FindClass("java/util/List");
+    jclass jclass_of_map = env->FindClass("java/util/Map");
+
+    if (env->IsInstanceOf(value.object<jobject>(),jclass_of_boolean)) {
+        v = QVariant::fromValue<bool>(value.callMethod<jboolean>("booleanValue","()Z"));
+    } else if (env->IsInstanceOf(value.object<jobject>(),jclass_of_integer)) {
+        v = value.callMethod<jint>("intValue","()I");
+    } else if (env->IsInstanceOf(value.object<jobject>(),jclass_of_string)) {
+        v = value.toString();
+    } else if (env->IsInstanceOf(value.object<jobject>(), jclass_of_map)) {
+        v = createVariantMap(value.object<jobject>());
+    } else if (env->IsInstanceOf(value.object<jobject>(),jclass_of_list)) {
+        QVariantList list;
+        int count = value.callMethod<jint>("size","()I");
+        for (int i = 0 ; i < count ; i++) {
+            QAndroidJniObject item = value.callObjectMethod("get","(I)Ljava/lang/Object;",i);
+            list.append(convertToQVariant(item));
+        }
+        v = list;
+    }
+
+    env->DeleteLocalRef(jclass_of_string);
+    env->DeleteLocalRef(jclass_of_integer);
+    env->DeleteLocalRef(jclass_of_boolean);
+    env->DeleteLocalRef(jclass_of_list);
+    env->DeleteLocalRef(jclass_of_map);
+
+    return v;
+}
+
+static QVariantMap createVariantMap(jobject data) {
+    QVariantMap res;
+
+    QAndroidJniEnvironment env;
+    /* Reference : https://community.oracle.com/thread/1549999 */
+
+    // Get the HashMap Class
+    jclass jclass_of_hashmap = (env)->GetObjectClass(data);
+
+    // Get link to Method "entrySet"
+    jmethodID entrySetMethod = (env)->GetMethodID(jclass_of_hashmap, "entrySet", "()Ljava/util/Set;");
+
+    // Invoke the "entrySet" method on the HashMap object
+    jobject jobject_of_entryset = env->CallObjectMethod(data, entrySetMethod);
+
+    // Get the Set Class
+    jclass jclass_of_set = (env)->FindClass("java/util/Set"); // Problem during compilation !!!!!
+
+    if (jclass_of_set == 0) {
+         qWarning() << "java/util/Set lookup failed\n";
+         return res;
+    }
+
+    // Get link to Method "iterator"
+    jmethodID iteratorMethod = env->GetMethodID(jclass_of_set, "iterator", "()Ljava/util/Iterator;");
+
+    // Invoke the "iterator" method on the jobject_of_entryset variable of type Set
+    jobject jobject_of_iterator = env->CallObjectMethod(jobject_of_entryset, iteratorMethod);
+
+    // Get the "Iterator" class
+    jclass jclass_of_iterator = (env)->FindClass("java/util/Iterator");
+
+    // Get link to Method "hasNext"
+    jmethodID hasNextMethod = env->GetMethodID(jclass_of_iterator, "hasNext", "()Z");
+
+    jmethodID nextMethod = env->GetMethodID(jclass_of_iterator, "next", "()Ljava/lang/Object;");
+
+    while (env->CallBooleanMethod(jobject_of_iterator, hasNextMethod) ) {
+        jobject jEntry = env->CallObjectMethod(jobject_of_iterator,nextMethod);
+        QAndroidJniObject entry = QAndroidJniObject(jEntry);
+        QAndroidJniObject key = entry.callObjectMethod("getKey","()Ljava/lang/Object;");
+        QAndroidJniObject value = entry.callObjectMethod("getValue","()Ljava/lang/Object;");
+        QString k = key.toString();
+
+        QVariant v = convertToQVariant(value);
+
+        env->DeleteLocalRef(jEntry);
+
+        if (v.isNull()) {
+            continue;
+        }
+
+        res[k] = v;
+    }
+
+    if (env->ExceptionOccurred()) {
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+    }
+
+    env->DeleteLocalRef(jclass_of_hashmap);
+    env->DeleteLocalRef(jobject_of_entryset);
+    env->DeleteLocalRef(jclass_of_set);
+    env->DeleteLocalRef(jobject_of_iterator);
+    env->DeleteLocalRef(jclass_of_iterator);
+
+    return res;
+}
+
+static jobject convertToJObject(QVariant v) {
+    jobject res = 0;
+    QAndroidJniEnvironment env;
+
+    if (v.type() == QVariant::String) {
+        QString str = v.toString();
+        res = env->NewStringUTF(str.toLocal8Bit().data());
+    } else if (v.type() == QVariant::Int) {
+        jclass integerClass = env->FindClass("java/lang/Integer");
+        jmethodID integerConstructor = env->GetMethodID(integerClass, "<init>", "(I)V");
+
+        res = env->NewObject(integerClass,integerConstructor,v.toInt());
+
+        env->DeleteLocalRef(integerClass);
+    } else if (v.type() == QVariant::Bool) {
+        jclass booleanClass = env->FindClass("java/lang/Boolean");
+        jmethodID booleanConstructor = env->GetMethodID(booleanClass,"<init>","(Z)V");
+
+        res = env->NewObject(booleanClass,booleanConstructor,v.toBool());
+
+        env->DeleteLocalRef(booleanClass);
+
+    } else if (v.type() == QVariant::Map) {
+        res = createHashMap(v.toMap());
+    } else  if (v.type() == QVariant::List){
+        QVariantList list = v.value<QVariantList>();
+        jclass arrayListClass = env->FindClass("java/util/ArrayList");
+        jmethodID init = env->GetMethodID(arrayListClass, "<init>", "(I)V");
+        res = env->NewObject( arrayListClass, init, list.size());
+
+        jmethodID add = env->GetMethodID( arrayListClass, "add",
+                    "(Ljava/lang/Object;)Z");
+
+        for (int i = 0 ; i < list.size() ; i++) {
+            jobject item = convertToJObject(list.at(i));
+            env->CallBooleanMethod(res,add, item);
+            env->DeleteLocalRef(item);
+        }
+
+        env->DeleteLocalRef(arrayListClass);
+    } else {
+        qWarning() << "QASystemDispatcher: Non-supported data type - " <<  v.type();
+    }
+    return res;
+}
+
+static jobject createHashMap(const QVariantMap &data) {
+    QAndroidJniEnvironment env;
+
+    jclass mapClass = env->FindClass("java/util/HashMap");
+
+    if (mapClass == NULL)  {
+        qWarning() << "Failed to find class" << "java/util/HashMap";
+        return NULL;
+    }
+
+    jsize map_len = data.size();
+
+    jmethodID init = env->GetMethodID(mapClass, "<init>", "(I)V");
+    jobject hashMap = env->NewObject( mapClass, init, map_len);
+
+    jmethodID put = env->GetMethodID( mapClass, "put",
+                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
+    QMapIterator<QString, QVariant> iter(data);
+    while (iter.hasNext()) {
+        iter.next();
+
+        QString key = iter.key();
+        jstring jkey = env->NewStringUTF(key.toLocal8Bit().data());
+        QVariant v = iter.value();
+        jobject item = convertToJObject(v);
+
+        if (item == 0) {
+            continue;
+        }
+
+        env->CallObjectMethod(hashMap,put,jkey,item);
+        env->DeleteLocalRef(item);
+        env->DeleteLocalRef(jkey);
+     }
+
+    if (env->ExceptionOccurred()) {
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+    }
+
+    env->DeleteLocalRef(mapClass);
+
+    return hashMap;
+}
+
+static void jniEmit(JNIEnv* env,jobject object,jstring name,jobject data) {
+    Q_UNUSED(object);
+    Q_UNUSED(env);
+
+    QAndroidJniObject tmp(name);
+    QString str = tmp.toString();
+
+    QVariantMap map;
+
+    if (data != 0) {
+        map = createVariantMap(data);
+    }
+
+    if (m_instance.isNull()) {
+        return;
+    }
+
+    QMetaObject::invokeMethod(m_instance.data(),"dispatched",Qt::AutoConnection,
+                              Q_ARG(QString, str),
+                              Q_ARG(QVariantMap,map));
+}
+
+
+#endif
+
+QASystemDispatcher::QASystemDispatcher(QObject* parent) : QObject(parent)
+{
+
+}
+
+QASystemDispatcher::~QASystemDispatcher()
+{
+
+}
+
+QASystemDispatcher *QASystemDispatcher::instance()
+{
+    if (!m_instance) {
+        QCoreApplication* app = QCoreApplication::instance();
+        m_instance = new QASystemDispatcher(app);
+    }
+    return m_instance;
+}
+
+void QASystemDispatcher::dispatch(QString type, QVariantMap message)
+{
+    Q_UNUSED(type);
+    Q_UNUSED(message);
+#ifdef Q_OS_ANDROID
+    QAndroidJniEnvironment env;
+
+    jstring jType = env->NewStringUTF(type.toLocal8Bit().data());
+    jobject jData = createHashMap(message);
+    QAndroidJniObject::callStaticMethod<void>(JCLASS_Name, "dispatch",
+                                              DISPATCH_SIGNATURE,
+                                              jType,jData);
+    env->DeleteLocalRef(jType);
+    env->DeleteLocalRef(jData);
+
+#else
+    static bool dispatching = false;
+    static QQueue<QPair<QString,QVariantMap> > queue;
+
+
+    if (dispatching) {
+        queue.enqueue(QPair<QString,QVariantMap> (type,message) );
+        return;
+    }
+
+    dispatching = true;
+    emit dispatched(type,message);
+
+
+qWarning() << "QASystemDispatcher: emitted"
+
+    while (queue.size() > 0) {
+        QPair<QString,QVariantMap> pair = queue.dequeue();
+        emit dispatched(pair.first,pair.second);
+    }
+    dispatching = false;
+#endif
+}
+
+void QASystemDispatcher::loadClass(QString javaClassName)
+{
+    QVariantMap message;
+    message["className"] = javaClassName;
+
+    dispatch("quickandroid.SystemDispatcher.loadClass",message);
+}
+
+void QASystemDispatcher::registerNatives()
+{
+#ifdef Q_OS_ANDROID
+    QAndroidJniEnvironment env;
+    jclass clazz = env->FindClass(JCLASS_Name);
+    if (!clazz)
+    {
+        qCritical() << QString("Can't find %1 class").arg(QString(JCLASS_Name));
+        return ;
+    }
+
+    JNINativeMethod methods[] =
+    {
+        {"jniEmit", EMIT_SIGNATURE, (void *)&jniEmit},
+    };
+
+    int numMethods = sizeof(methods) / sizeof(methods[0]);
+    if (env->RegisterNatives(clazz, methods, numMethods) < 0) {
+        if (env->ExceptionOccurred()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+            qCritical() << "Exception occurred!!!";
+            return;
+        }
+    }
+
+    QAndroidJniObject::callStaticMethod<void>(JCLASS_Name, "init",
+                                              "()V");
+#endif
+}

source-android/common/qasystemdispatcher.h

@@ -0,0 +1,47 @@
+// Author:  Ben Lau (https://github.com/benlau)
+#pragma once
+#include <QObject>
+#include <QVariantMap>
+
+/// QASystemDispatcher provides an simple messaging interface between C/C++/QML and Java code.
+
+class QASystemDispatcher : public QObject
+{
+    Q_OBJECT
+public:
+    ~QASystemDispatcher();
+    static QASystemDispatcher* instance();
+
+    /// Dispatch a message via Dispatcher
+    /** The message will be first passed to Java's SystemDispatcher and invoke
+     * registered listener. Once it is finished, it will emit the
+     * "dispatched" signal.
+     *
+     */
+    Q_INVOKABLE void dispatch(QString type , QVariantMap message = QVariantMap());
+
+    /// Load a Java class
+    /** It will dispatch a message to Java and let it to load a Java class. That
+     * will force to run code in static block.
+     *
+     */
+    Q_INVOKABLE void loadClass(QString javaClassName);
+
+    /// Register JNI native methods. This function must be called in JNI_OnLoad. Otherwise, the messenger will not be working
+    static void registerNatives();
+
+    /// The name of message that will be dispatched during Activity.onActivityResult.
+    static QString ACTIVITY_RESULT_MESSAGE;
+
+    /// The name of message that will be dispatched during Activity.onResume.
+    static QString ACTIVITY_RESUME_MESSAGE;
+
+signals:
+    /// The signal is emitted when a message is dispatched.
+    void dispatched(QString type , QVariantMap message);
+
+public:
+    explicit QASystemDispatcher(QObject* parent = 0);
+
+};
+

source-android/common/quickandroid.cpp

@@ -0,0 +1,22 @@
+#include <QtQml>
+#include <QVariantMap>
+#include "quickandroid.h"
+//#include "qadevice.h"
+//#include "qamousesensor.h"
+
+#ifdef Q_OS_ANDROID
+#include <QAndroidJniEnvironment>
+#include <QAndroidJniObject>
+#endif
+
+void QuickAndroid::registerTypes()
+{
+    // "A" has been changed to a QML object. So now this function will do nothing.
+    // Keep here for compatible purpose only.
+}
+
+//qreal QuickAndroid::dp()
+//{
+//    return QADevice::readDp();
+//}
+

source-android/common/quickandroid.h

@@ -0,0 +1,21 @@
+#ifndef QUICKANDROID_H
+#define QUICKANDROID_H
+
+#include <QtGlobal>
+/// Quick Android Context
+
+class QuickAndroid
+{
+public:
+    static void registerTypes();
+
+    /// Obtain the detected "dp" value.
+    /** This function has been deprecated. Please use QADevice::dp()
+       @deprecated.
+     * @brief dp
+     * @return The detected "dp" value
+    */
+    static qreal dp();
+};
+
+#endif // QUICKANDROID_H

source-android/common/xhr.cpp

@@ -3,7 +3,10 @@
 #include <QHttpPart>
 #include <QTextCodec>
 #include <QUrlQuery>
-
+#include <QNetworkCookieJar>
+#include <QNetworkCookie>
+#include <QList>
+#include <QDataStream>
 #include "uploadableimage.h"
 
 XHR *XHR::instance()
@@ -114,7 +117,8 @@ void XHR::get()
     QByteArray loginData = m_login.toLocal8Bit().toBase64();
     QString headerData = "Basic " + loginData;
     request.setRawHeader("Authorization", headerData.toLocal8Bit());
-
+//    QNetworkCookieJar* cJar = new QNetworkCookieJar;
+//    manager.setCookieJar(cJar);
 
     request.setUrl(requrl);
     reply = manager.get(request);
@@ -184,7 +188,7 @@ void XHR::onReplySuccess()
     qDebug() << "!";
     emit this->success( bufferToString() );
     buffer.clear();
-    reply->deleteLater();
+//    reply->deleteLater();
 }
 
 void XHR::onRequestFinished()
@@ -206,6 +210,15 @@ void XHR::onReadyRead()
 {
     qDebug() << ".";
     buffer += reply->readAll();
+//    QList<QNetworkCookie> list =  manager.cookieJar()->cookiesForUrl(m_url);
+//        QFile f("/home/pankraz/cookie.txt");
+//        f.open(QIODevice::ReadWrite);
+//        for(int i = 0; i < list.size(); ++i){
+//            QDataStream s(&f);
+//            s << list.at(i).toRawForm();
+//        }
+//        f.close();
+
 }
 
 //void XHR::updateDownloadProgress(qint64 bytesRead, qint64 totalBytes)
@@ -227,5 +240,3 @@ QString XHR::bufferToString()
 {
     return QTextCodec::codecForName("utf-8")->toUnicode(buffer);
 }
-
-