Merge lp:~zeller-benjamin/qtcreator-plugin-ubuntu/bug-1387302 into lp:qtcreator-plugin-ubuntu

[Benjamin Zeller]

- Fix bug lp:1387302
  "Support selection of the 14.10 final framework version"
- Dynamically query frameworks from the server to make sure the list
  is up2date. Fall back to resource files or last query if no network
  is available.
- Fix update problem in the manifest editor

- Fix bug lp:1387302
  "Support selection of the 14.10 final framework version"
- Dynamically query frameworks from the server to make sure the list
  is up2date. Fall back to resource files or last query if no network
  is available.
- Fix update problem in the manifest editor

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:290
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/464/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/232
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/232

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/464/rebuild

review: Approve (continuous-integration)

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/bug-1387302]

291. By Benjamin Zeller on 2014-11-03

More easy sorting function for the frameworks

292. By Benjamin Zeller on 2014-11-03

sort frameworks by base version, and not by base string:
ubuntu-sdk-14.10 vs ubuntu-core-15.04

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:292
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/465/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/233
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/233

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/465/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

OK

review: Approve

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/bug-1387302]

293. By Benjamin Zeller on 2014-11-03

Make sure the request returns valid data, and in case it does not fall
back to the default values (if the frameworkCache is empty)

=== added file 'src/ubuntu/click-framework.json'
--- src/ubuntu/click-framework.json	1970-01-01 00:00:00 +0000
+++ src/ubuntu/click-framework.json	2014-11-03 14:19:38 +0000
@@ -0,0 +1,1 @@
+{"ubuntu-sdk-14.04-html": "available", "ubuntu-sdk-14.04-papi-dev1": "deprecated", "ubuntu-sdk-14.10-papi": "available", "ubuntu-sdk-14.10-qml": "available", "ubuntu-sdk-14.04-dev1": "deprecated", "ubuntu-sdk-14.04-html-dev1": "deprecated", "ubuntu-sdk-14.04": "available", "ubuntu-sdk-14.10-html": "available", "ubuntu-sdk-14.04-papi": "available", "ubuntu-sdk-13.10": "deprecated", "ubuntu-sdk-14.10-qml-dev3": "available", "ubuntu-sdk-14.10-qml-dev2": "available", "ubuntu-sdk-14.10-qml-dev1": "obsolete", "ubuntu-sdk-14.04-qml-dev1": "deprecated", "ubuntu-sdk-14.10-papi-dev2": "available", "ubuntu-sdk-14.10-papi-dev3": "available", "ubuntu-sdk-14.10-papi-dev1": "obsolete", "ubuntu-sdk-14.10": "available", "ubuntu-sdk-14.04-qml": "available", "ubuntu-sdk-14.10-dev1": "obsolete", "ubuntu-sdk-14.10-dev2": "available", "ubuntu-sdk-14.10-dev3": "available", "ubuntu-sdk-14.10-html-dev3": "available", "ubuntu-sdk-14.10-html-dev2": "available", "ubuntu-sdk-14.10-html-dev1": "obsolete"}

=== modified file 'src/ubuntu/resources.qrc'
--- src/ubuntu/resources.qrc	2014-10-10 07:46:06 +0000
+++ src/ubuntu/resources.qrc	2014-11-03 14:19:38 +0000
@@ -22,5 +22,6 @@
         <file>images/security-alert.svg</file>
         <file>images/view-expand.svg</file>
         <file>images/view-collapse.svg</file>
+        <file>click-framework.json</file>
     </qresource>
 </RCC>

=== modified file 'src/ubuntu/ubuntuclickmanifest.cpp'
--- src/ubuntu/ubuntuclickmanifest.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubuntuclickmanifest.cpp	2014-11-03 14:19:38 +0000
@@ -315,12 +315,12 @@
 
         QString defFramework;
         if(isUbuntuProject && isUbuntuHtmlProject) {
-            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("html"),UbuntuClickTool::clickTargetFromTarget(proj->activeTarget()));
+            defFramework = UbuntuClickFrameworkProvider::getMostRecentFramework(QLatin1String("html"));
 
             if(defFramework.isEmpty())
                 defFramework = QLatin1String(Constants::UBUNTU_DEFAULT_HTML_FRAMEWORK);
         } else {
-            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("qml"),UbuntuClickTool::clickTargetFromTarget(proj->activeTarget()));
+            defFramework = UbuntuClickFrameworkProvider::getMostRecentFramework(QLatin1String("qml"));
 
             if(defFramework.isEmpty())
                 defFramework = QLatin1String(Constants::UBUNTU_DEFAULT_QML_FRAMEWORK);

=== modified file 'src/ubuntu/ubuntuclicktool.cpp'
--- src/ubuntu/ubuntuclicktool.cpp	2014-09-28 16:47:39 +0000
+++ src/ubuntu/ubuntuclicktool.cpp	2014-11-03 14:19:38 +0000
@@ -24,24 +24,19 @@
 
 #include <QRegularExpression>
 #include <QDir>
-#include <QPlainTextEdit>
-#include <QTextCursor>
-#include <QFont>
-#include <QFormLayout>
-#include <QLabel>
-#include <QDialogButtonBox>
-#include <QComboBox>
 #include <QMessageBox>
-#include <QAction>
 #include <QInputDialog>
-#include <QPushButton>
 #include <QProcess>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QTimer>
+#include <QFile>
+#include <QStandardPaths>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonParseError>
 
 #include <coreplugin/icore.h>
-#include <coreplugin/actionmanager/actioncontainer.h>
-#include <coreplugin/actionmanager/actionmanager.h>
-#include <coreplugin/progressmanager/futureprogress.h>
-#include <coreplugin/progressmanager/progressmanager.h>
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/project.h>
@@ -209,133 +204,6 @@
 }
 
 /*!
- * \brief UbuntuClickTool::getSupportedFrameworks
- * returns all available frameworks on the host system
- */
-QStringList UbuntuClickTool::getSupportedFrameworks(const UbuntuClickTool::Target *target)
-{
-#if 0
-    QProcess proc;
-    proc.setProgram(QStringLiteral("click"));
-
-    QStringList args;
-    if (target) {
-        args << QStringLiteral("chroot")
-             << QStringLiteral("-a")
-             << target->architecture
-             << QStringLiteral("-f")
-             << target->framework
-             << QStringLiteral("run")
-             << QStringLiteral("click");
-    }
-    args << QStringLiteral("framework")
-         << QStringLiteral("list");
-
-    if(debug) qDebug()<<"click"<<Utils::QtcProcess::joinArgs(args);
-    proc.setArguments(args);
-    proc.start();
-    if (!proc.waitForFinished()) {
-        proc.kill();
-        return QStringList();
-    }
-
-    if(proc.exitCode() != 0 || proc.exitStatus() != QProcess::NormalExit)
-        return QStringList();
-
-    QStringList allFws = QString::fromLocal8Bit(proc.readAllStandardOutput()).split(QStringLiteral("\n"),QString::SkipEmptyParts);
-
-    //reverse the list
-    QStringList result;
-    result.reserve( allFws.size() );
-    std::reverse_copy( allFws.begin(), allFws.end(), std::back_inserter( result ) );
-
-    return result;
-#endif
-
-#if 0
-    if (!target) {
-        QStringList items;
-        QDir frameworksDir(QLatin1String(Constants::UBUNTU_CLICK_FRAMEWORKS_BASEPATH));
-
-        if(!frameworksDir.exists())
-            return items;
-
-        QStringList availableFrameworkFiles = frameworksDir.entryList(QStringList()<<QLatin1String("*.framework"),
-                                                                      QDir::Files | QDir::NoDotAndDotDot,
-                                                                      QDir::Name | QDir::Reversed);
-
-        QStringList availableFrameworks;
-        foreach(QString fw, availableFrameworkFiles) {
-            fw.replace(QLatin1String(".framework"),QString());
-            availableFrameworks.append(fw);
-        }
-
-        if(debug) qDebug()<<"Available Frameworks on the host"<<availableFrameworks;
-        return availableFrameworks;
-    } else {
-        //hardcode for now, click chroots are broken, click is not installed and even if its installed
-        //it does not show any valid informations
-        if(target->majorVersion == 14 && target->minorVersion == 10) {
-            return QStringList() << QStringLiteral("ubuntu-sdk-14.10-qml-dev3")
-                                 << QStringLiteral("ubuntu-sdk-14.10-qml-dev2")
-                                 << QStringLiteral("ubuntu-sdk-14.10-qml-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.10-papi-dev2")
-                                 << QStringLiteral("ubuntu-sdk-14.10-papi-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.10-html-dev2")
-                                 << QStringLiteral("ubuntu-sdk-14.10-html-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.10-dev2")
-                                 << QStringLiteral("ubuntu-sdk-14.10-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04")
-                                 << QStringLiteral("ubuntu-sdk-14.04-qml")
-                                 << QStringLiteral("ubuntu-sdk-14.04-qml-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-papi")
-                                 << QStringLiteral("ubuntu-sdk-14.04-papi-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-html")
-                                 << QStringLiteral("ubuntu-sdk-14.04-html-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-dev1")
-                                 << QStringLiteral("ubuntu-sdk-13.10");
-        } else if (target->majorVersion == 14 && target->minorVersion == 4){
-            return QStringList() << QStringLiteral("ubuntu-sdk-14.04")
-                                 << QStringLiteral("ubuntu-sdk-14.04-qml")
-                                 << QStringLiteral("ubuntu-sdk-14.04-qml-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-papi")
-                                 << QStringLiteral("ubuntu-sdk-14.04-papi-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-html")
-                                 << QStringLiteral("ubuntu-sdk-14.04-html-dev1")
-                                 << QStringLiteral("ubuntu-sdk-14.04-dev1")
-                                 << QStringLiteral("ubuntu-sdk-13.10");
-        } else {
-            return QStringList() << QStringLiteral("ubuntu-sdk-13.10");
-        }
-    }
-#endif
-
-    //quick and dirty fix for trusty dev env
-    Q_UNUSED(target);
-    static QStringList frameworks {
-        QStringLiteral("ubuntu-sdk-14.10-qml-dev3"),
-        QStringLiteral("ubuntu-sdk-14.10-qml-dev2"),
-        QStringLiteral("ubuntu-sdk-14.10-qml-dev1"),
-        QStringLiteral("ubuntu-sdk-14.10-papi-dev2"),
-        QStringLiteral("ubuntu-sdk-14.10-papi-dev1"),
-        QStringLiteral("ubuntu-sdk-14.10-html-dev2"),
-        QStringLiteral("ubuntu-sdk-14.10-html-dev1"),
-        QStringLiteral("ubuntu-sdk-14.10-dev2"),
-        QStringLiteral("ubuntu-sdk-14.10-dev1"),
-        QStringLiteral("ubuntu-sdk-14.04"),
-        QStringLiteral("ubuntu-sdk-14.04-qml"),
-        QStringLiteral("ubuntu-sdk-14.04-qml-dev1"),
-        QStringLiteral("ubuntu-sdk-14.04-papi"),
-        QStringLiteral("ubuntu-sdk-14.04-papi-dev1"),
-        QStringLiteral("ubuntu-sdk-14.04-html"),
-        QStringLiteral("ubuntu-sdk-14.04-html-dev1"),
-        QStringLiteral("ubuntu-sdk-14.04-dev1"),
-        QStringLiteral("ubuntu-sdk-13.10")
-    };
-    return frameworks;
-}
-
-/*!
  * \brief UbuntuClickTool::targetExists
  * checks if the target is still available
  */
@@ -348,48 +216,6 @@
     return true;
 }
 
-/*!
- * \brief UbuntuClickTool::getMostRecentFramework
- * returns the framework with the highest number supporting the subFramework
- * or a empty string of no framework with the given \a subFramework was found
- */
-QString UbuntuClickTool::getMostRecentFramework(const QString &subFramework, const Target *target)
-{
-    //returned list is ordered from newest -> oldest framework
-    QStringList allFws = getSupportedFrameworks(target);
-    QString currFw;
-    foreach(const QString &framework, allFws) {
-        QString basename;
-        QStringList extensions;
-        QRegularExpression expr(QLatin1String(Constants::UBUNTU_CLICK_BASE_FRAMEWORK_REGEX));
-        QRegularExpressionMatch match = expr.match(framework);
-        if(match.hasMatch()) {
-            basename = match.captured(1);
-            extensions = QString(framework).replace(basename,
-                                                    QString()).split(QChar::fromLatin1('-'),
-                                                                     QString::SkipEmptyParts);
-        } else {
-            continue;
-        }
-        //this is a multi purpose framework
-        if (extensions.size() == 0
-                || (extensions.size() == 1 && extensions[0].startsWith(QLatin1String("dev")) )) {
-            if (currFw.isEmpty()) {
-                currFw = framework;
-            }
-            //if the subframework is empty we return
-            //the first baseframework we can find
-            if(subFramework.isEmpty())
-                return currFw;
-            continue;
-        }
-
-        if(extensions.contains(subFramework))
-            return framework;
-    }
-    return currFw;
-}
-
 /**
  * @brief UbuntuClickTool::listAvailableTargets
  * @return all currently existing chroot targets in the system
@@ -577,6 +403,320 @@
     return dbg.space();
 }
 
+
+/*!
+ * \class UbuntuClickFrameworkProvider::UbuntuClickFrameworkProvider
+ *
+ * The UbuntuClickFrameworkProvider makes sure the IDE knows the most recent
+ * framework list. It queries the Ubuntu servers for the list and fires frameworksUpdated()
+ * if a new list is available. Widgets showing the frameworks should update accordingly
+ *
+ * The framework -> policy mapping is still hardcoded because there is no current API to query
+ * it
+ *
+ * \note If no network connection is available the cache falls back to the last successful query or
+ *       the shipped framework list in the resource file
+ */
+
+
+struct FrameworkDesc{
+    FrameworkDesc() : develVersion(INT_MAX) {}
+    QString base;
+    QString baseVersion;
+    QString sub;
+    int develVersion;
+};
+
+//this is a horrible complicated sorting function, it should be replaced with something more trivial
+static FrameworkDesc fwDescFromString (const QString &fw)
+{
+    FrameworkDesc fwDesc;
+
+    QStringList ext;
+    fwDesc.base = UbuntuClickFrameworkProvider::getBaseFramework(fw,&ext);
+
+    int lastDash = fwDesc.base.lastIndexOf(QStringLiteral("-"));
+    if(lastDash > 0) {
+        fwDesc.baseVersion = fwDesc.base.mid(lastDash+1);
+        fwDesc.base        = fwDesc.base.mid(0,lastDash);
+    }
+
+    QString sub;
+    while(ext.size()) {
+        sub = ext.takeFirst();
+        if(sub.startsWith(QStringLiteral("dev"))) {
+            fwDesc.develVersion = sub.remove(QStringLiteral("dev")).toInt();
+        } else {
+            fwDesc.sub = sub;
+        }
+    }
+    return fwDesc;
+}
+
+
+static bool caseInsensitiveFWLessThan(const QString &s1, const QString &s2)
+{
+
+    FrameworkDesc fwDesc1 = fwDescFromString(s1);
+    FrameworkDesc fwDesc2 = fwDescFromString(s2);
+
+    int comp = QString::compare(fwDesc1.baseVersion,fwDesc2.baseVersion,Qt::CaseInsensitive);
+    if(comp < 0)
+        return false;
+    else if(comp > 0)
+        return true;
+    else {
+        //from here on we deal only with the same base framework
+        if(fwDesc1.sub.isEmpty() && !fwDesc2.sub.isEmpty())
+            return true;
+        else if(!fwDesc1.sub.isEmpty() && fwDesc2.sub.isEmpty())
+            return false;
+        else if(fwDesc1.sub == fwDesc2.sub)
+            return fwDesc1.develVersion > fwDesc2.develVersion;
+        else
+            return fwDesc1.sub > fwDesc2.sub;
+    }
+
+    //this should never be reached
+    return s1 > s2;
+}
+
+UbuntuClickFrameworkProvider *UbuntuClickFrameworkProvider::m_instance = nullptr;
+
+UbuntuClickFrameworkProvider::UbuntuClickFrameworkProvider()
+    : QObject(0),
+      m_policyCache {
+        {QStringLiteral("ubuntu-sdk-13.10"),QStringLiteral("1.0")},
+        {QStringLiteral("ubuntu-sdk-14.04"),QStringLiteral("1.1")},
+        {QStringLiteral("ubuntu-sdk-14.10"),QStringLiteral("1.2")}
+      },
+      m_manager(nullptr),
+      m_currentRequest(nullptr),
+      m_cacheUpdateTimer(nullptr)
+{
+    Q_ASSERT_X(m_instance == nullptr,Q_FUNC_INFO,"UbuntuClickFrameworkProvider can only be instantiated once");
+    m_instance = this;
+
+    m_cacheFilePath = QStringLiteral("%1/ubuntu-sdk/framework-cache.json")
+            .arg(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation));
+
+    m_manager = new QNetworkAccessManager(this);
+    m_cacheUpdateTimer = new QTimer(this);
+    m_cacheUpdateTimer->setInterval( 60 * 60 * 1000); //fire every hour
+    m_cacheUpdateTimer->start();
+
+    connect(m_cacheUpdateTimer,SIGNAL(timeout()),this,SLOT(updateFrameworks()));
+
+    //read the current state
+    readCache();
+
+    //fire a update
+    updateFrameworks(true);
+}
+
+UbuntuClickFrameworkProvider *UbuntuClickFrameworkProvider::instance()
+{
+    return m_instance;
+}
+
+QStringList UbuntuClickFrameworkProvider::supportedFrameworks() const
+{
+    return m_frameworkCache;
+}
+
+/*!
+ * \brief UbuntuClickTool::getMostRecentFramework
+ * returns the framework with the highest number supporting the subFramework
+ * or a empty string of no framework with the given \a subFramework was found
+ */
+QString UbuntuClickFrameworkProvider::mostRecentFramework(const QString &subFramework)
+{
+    //cache is ordered from newest -> oldest framework
+    QString currFw;
+    foreach(const QString &framework, m_frameworkCache) {
+        QString basename;
+        QStringList extensions;
+
+        basename = getBaseFramework(framework,&extensions);
+        if(basename.isEmpty())
+            continue;
+
+        //this is a multi purpose framework
+        if (extensions.size() == 0
+                || (extensions.size() == 1 && extensions[0].startsWith(QLatin1String("dev")) )) {
+            if (currFw.isEmpty()) {
+                currFw = framework;
+            }
+            //if the subframework is empty we return
+            //the first baseframework we can find
+            if(subFramework.isEmpty())
+                return currFw;
+            continue;
+        }
+
+        if(extensions.contains(subFramework))
+            return framework;
+    }
+    return currFw;
+}
+
+QString UbuntuClickFrameworkProvider::frameworkPolicy(const QString &fw) const
+{
+    QString base = getBaseFramework(fw);
+    if(m_policyCache.contains(base))
+        return m_policyCache[base];
+    return QString();
+}
+
+QStringList UbuntuClickFrameworkProvider::getSupportedFrameworks()
+{
+    return instance()->supportedFrameworks();
+}
+
+/*!
+ * \brief UbuntuClickTool::getMostRecentFramework
+ * \sa UbuntuClickFrameworkProvider::mostRecentFramework
+ */
+QString UbuntuClickFrameworkProvider::getMostRecentFramework(const QString &subFramework)
+{
+    return instance()->mostRecentFramework(subFramework);
+}
+
+QString UbuntuClickFrameworkProvider::getBaseFramework(const QString &framework, QStringList *extensions)
+{
+    QRegularExpression expr(QLatin1String(Constants::UBUNTU_CLICK_BASE_FRAMEWORK_REGEX));
+    QRegularExpressionMatch match = expr.match(framework);
+    if(match.hasMatch()) {
+        QString basename = match.captured(1);
+        if(extensions) {
+            *extensions = QString(framework).replace(basename,
+                                                     QString()).split(QChar::fromLatin1('-'),
+                                                                      QString::SkipEmptyParts);
+        }
+        return basename;
+    }
+    return QString();
+}
+
+void UbuntuClickFrameworkProvider::requestFinished()
+{
+    //if the current request is not set anymore we already called deleteLater
+    if(!m_currentRequest)
+        return;
+
+    QByteArray data = m_currentRequest->readAll();
+
+    //make sure everything is cleaned up
+    m_currentRequest->deleteLater();
+    m_currentRequest = nullptr;
+
+    //if we received nothing, stop
+    if(data.isEmpty())
+        return;
+
+    //make sure we got valid data
+    QStringList newData = parseData(data);
+    if(newData.isEmpty())
+        return;
+
+    bool cacheIsUp2Date = (newData == m_frameworkCache);
+    if(!cacheIsUp2Date) {
+        QFile cache(m_cacheFilePath);
+        if(cache.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+            cache.write(data);
+            cache.close();
+        } else {
+            qWarning()<<"Could not create framework cache file, falling back to default values";
+        }
+        m_frameworkCache = newData;
+        emit frameworksUpdated();
+    }
+}
+
+void UbuntuClickFrameworkProvider::requestError()
+{
+    //if the current request is not set anymore we already called deleteLater
+    if(!m_currentRequest)
+        return;
+
+    qWarning()<<"Could not update the framework cache file. Probably there is no network connection.";
+
+    m_currentRequest->deleteLater();
+    m_currentRequest = nullptr;
+}
+
+void UbuntuClickFrameworkProvider::updateFrameworks(bool force)
+{
+    if(m_currentRequest)
+        return;
+
+    if(!force) {
+        //update every 12 hours
+        QFileInfo info(m_cacheFilePath);
+        if(info.exists() && info.lastModified().secsTo(QDateTime::currentDateTime()) < (12*60*60))
+            return;
+    }
+
+    //fire the request
+    m_currentRequest = m_manager->get(QNetworkRequest(QUrl(QStringLiteral("https://myapps.developer.ubuntu.com/dev/api/click-framework/"))));
+    connect(m_currentRequest,SIGNAL(finished()),this,SLOT(requestFinished()));
+    connect(m_currentRequest,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(requestError()));
+}
+
+void UbuntuClickFrameworkProvider::readCache()
+{
+    QFile cache(m_cacheFilePath);
+    if(!cache.exists() || !cache.open(QIODevice::ReadOnly)) {
+        readDefaultValues();
+        return;
+    }
+
+    QStringList data = parseData(cache.readAll());
+    if(!data.isEmpty()) {
+        m_frameworkCache = data;
+        emit frameworksUpdated();
+    } else {
+        //if the cache is empty fall back to the default values
+        if(m_frameworkCache.isEmpty())
+            readDefaultValues();
+    }
+}
+
+void UbuntuClickFrameworkProvider::readDefaultValues()
+{
+    QFile cache(QStringLiteral(":/ubuntu/click-framework.json"));
+    if(Q_UNLIKELY(cache.open(QIODevice::ReadOnly) == false)) {
+        //This codepath is very unlikely, but lets still make sure there is a message to the user
+        qWarning()<<"Could not read cache file OR default values. No frameworks are available to select from";
+        return;
+    }
+
+    QStringList data = parseData(cache.readAll());
+    if(!data.isEmpty()) {
+        m_frameworkCache = data;
+        emit frameworksUpdated();
+    }
+}
+
+QStringList UbuntuClickFrameworkProvider::parseData(const QByteArray &data) const
+{
+    QJsonParseError parseError;
+    parseError.error = QJsonParseError::NoError;
+
+    QJsonDocument doc = QJsonDocument::fromJson(data,&parseError);
+    if(parseError.error != QJsonParseError::NoError) {
+        qWarning()<< "Could not parse the framework cache: "
+                  << parseError.errorString();
+        return QStringList();
+    }
+
+    QJsonObject obj   = doc.object();
+    QStringList result  = obj.keys();
+    qSort(result.begin(),result.end(),caseInsensitiveFWLessThan);
+
+    return result;
+}
+
 } // namespace Internal
 } // namespace Ubuntu
 

=== modified file 'src/ubuntu/ubuntuclicktool.h'
--- src/ubuntu/ubuntuclicktool.h	2014-09-28 09:15:53 +0000
+++ src/ubuntu/ubuntuclicktool.h	2014-11-03 14:19:38 +0000
@@ -33,6 +33,9 @@
 class QPlainTextEdit;
 class QLabel;
 class QAction;
+class QTimer;
+class QNetworkAccessManager;
+class QNetworkReply;
 
 namespace ProjectExplorer {
     class Project;
@@ -71,8 +74,6 @@
 
     static QString targetBasePath (const Target& target);
     static bool getTargetFromUser (Target* target, const QString &framework=QString());
-    static QStringList getSupportedFrameworks (const Target *target);
-    static QString getMostRecentFramework ( const QString &subFramework, const Target *target );
 
     static bool          targetExists (const Target& target);
     static QList<Target> listAvailableTargets (const QString &framework=QString());
@@ -85,6 +86,46 @@
 
 QDebug operator<<(QDebug dbg, const UbuntuClickTool::Target& t);
 
+class UbuntuClickFrameworkProvider : public QObject
+{
+    Q_OBJECT
+
+public:
+    UbuntuClickFrameworkProvider();
+    static UbuntuClickFrameworkProvider *instance();
+
+    QStringList supportedFrameworks() const;
+    QString mostRecentFramework ( const QString &subFramework);
+    QString frameworkPolicy (const QString &fw) const;
+
+    static QStringList getSupportedFrameworks ();
+    static QString getMostRecentFramework ( const QString &subFramework);
+    static QString getBaseFramework (const QString &framework, QStringList *extensions = 0);
+
+signals:
+    void frameworksUpdated();
+
+private slots:
+    void requestFinished  ();
+    void requestError     ();
+    void updateFrameworks (bool force = false);
+
+private:
+    void readCache ();
+    void readDefaultValues ();
+    QStringList parseData  ( const QByteArray &data) const;
+
+private:
+    QStringList            m_frameworkCache;
+    QString                m_cacheFilePath;
+    QMap<QString,QString>  m_policyCache;
+
+    QNetworkAccessManager *m_manager;
+    QNetworkReply         *m_currentRequest;
+    QTimer                *m_cacheUpdateTimer;
+    static UbuntuClickFrameworkProvider *m_instance;
+};
+
 } // namespace Internal
 } // namespace Ubuntu
 

=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2014-10-13 15:33:46 +0000
+++ src/ubuntu/ubuntuconstants.h	2014-11-03 14:19:38 +0000
@@ -460,7 +460,7 @@
 const char UBUNTU_CLICK_OPEN_TERMINAL_ERROR[] = "Error when starting terminal";
 const char UBUNTU_CLICK_TARGETS_REGEX[] = "^%1-(.*)-([A-Za-z0-9]+)$";
 const char UBUNTU_CLICK_TARGETS_FRAMEWORK_REGEX[] = "^%1-(%2)-([A-Za-z0-9]+)$";
-const char UBUNTU_CLICK_BASE_FRAMEWORK_REGEX[] = "(ubuntu-sdk-[0-9]{1,2}.[0-9]{1,2})";
+const char UBUNTU_CLICK_BASE_FRAMEWORK_REGEX[] = "(ubuntu-(.*)-[0-9]{1,2}.[0-9]{1,2})";
 const char UBUNTU_CLICK_VERSION_REGEX[] = "^DISTRIB_RELEASE=([0-9]+)\\.([0-9]+)$";
 const char UBUNTU_CLICK_SERIES_REGEX[]  = "^DISTRIB_CODENAME=([A-Za-z]+)$";
 
@@ -540,8 +540,8 @@
 const char UBUNTU_FRAMEWORK_14_10_BASENAME[] = "ubuntu-sdk-14.10";
 const char UBUNTU_FRAMEWORK_14_04_BASENAME[] = "ubuntu-sdk-14.04";
 const char UBUNTU_FRAMEWORK_13_10_BASENAME[] = "ubuntu-sdk-13.10";
-const char UBUNTU_DEFAULT_QML_FRAMEWORK[]    = "ubuntu-sdk-14.04-qml-dev1";
-const char UBUNTU_DEFAULT_HTML_FRAMEWORK[]   = "ubuntu-sdk-14.04-html";
+const char UBUNTU_DEFAULT_QML_FRAMEWORK[]    = "ubuntu-sdk-14.10-qml";
+const char UBUNTU_DEFAULT_HTML_FRAMEWORK[]   = "ubuntu-sdk-14.10-html";
 const char UBUNTU_UNKNOWN_FRAMEWORK_NAME[]   = "Unknown framework";
 const int  UBUNTU_UNKNOWN_FRAMEWORK_DATA     = 0xdeadbeef;
 

=== modified file 'src/ubuntu/ubuntumanifesteditorwidget.cpp'
--- src/ubuntu/ubuntumanifesteditorwidget.cpp	2014-08-19 06:15:32 +0000
+++ src/ubuntu/ubuntumanifesteditorwidget.cpp	2014-11-03 14:19:38 +0000
@@ -76,6 +76,9 @@
     connect(m_ui->lineEdit_name,SIGNAL(textChanged(QString)),this,SLOT(setDirty()));
     connect(m_ui->lineEdit_title,SIGNAL(textChanged(QString)),this,SLOT(setDirty()));
     connect(m_ui->lineEdit_version,SIGNAL(textChanged(QString)),this,SLOT(setDirty()));
+    connect(UbuntuClickFrameworkProvider::instance(),SIGNAL(frameworksUpdated()),this,SLOT(updateFrameworkList()));
+
+    updateFrameworkList();
 
     return w;
 }
@@ -148,31 +151,17 @@
     if(data != m_ui->lineEdit_description->text())
         m_ui->lineEdit_description->setText(data);
 
-    updateFrameworkList();
-    int idx = m_ui->comboBoxFramework->findText(m_manifest->frameworkName());
-
     //disable the currentIndexChanged signal, we need to check outselves if
     //the data has changed
     m_ui->comboBoxFramework->blockSignals(true);
-    QVariant fwData = m_ui->comboBoxFramework->currentData();
-
-    //if the framework name is not valid set to empty item
-    //just some data to easily find the unknown framework item without
-    //using string compare
-    if(idx < 0) {
-        if(m_ui->comboBoxFramework->findData(Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA) < 0)
-            m_ui->comboBoxFramework->addItem(tr(Constants::UBUNTU_UNKNOWN_FRAMEWORK_NAME),Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA);
-
-        m_ui->comboBoxFramework->setCurrentIndex(m_ui->comboBoxFramework->count()-1);
-    } else {
-        m_ui->comboBoxFramework->setCurrentIndex(idx);
-        m_ui->comboBoxFramework->removeItem(m_ui->comboBoxFramework->findData(Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA));
-    }
+
+    QString fwText = m_ui->comboBoxFramework->currentText();
+    selectFramework(source->frameworkName());
 
     m_ui->comboBoxFramework->blockSignals(false);
 
     //set the dirty flag manually in case something has changed
-    if(m_ui->comboBoxFramework->currentData() != fwData)
+    if(m_ui->comboBoxFramework->currentText() != fwText)
         setDirty();
 
     QSet<int> idxToKeep;
@@ -241,7 +230,7 @@
     m_manifest->setTitle(m_ui->lineEdit_title->text());
     m_manifest->setDescription(m_ui->lineEdit_description->text());
 
-    if(m_ui->comboBoxFramework->currentText() != tr(Constants::UBUNTU_UNKNOWN_FRAMEWORK_NAME))
+    if(m_ui->comboBoxFramework->currentData() != Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA)
         m_manifest->setFrameworkName(m_ui->comboBoxFramework->currentText());
 
     for(int idx = 0; idx < m_ui->comboBoxHook->count(); idx++) {
@@ -266,7 +255,6 @@
         m_manifest->setHook(hook);
     }
 
-
     QString result = m_manifest->raw()+QStringLiteral("\n");
     QString src    = m_sourceEditor->toPlainText();
     if (result == src)
@@ -281,19 +269,36 @@
 
 void UbuntuManifestEditorWidget::updateFrameworkList()
 {
-    const QString docPath(m_sourceEditor->baseTextDocument()->filePath());
-
-    const UbuntuClickTool::Target *t = 0;
-    ProjectExplorer::Project* myProject = ubuntuProject(docPath);
-    if (myProject)
-        t = UbuntuClickTool::clickTargetFromTarget(myProject->activeTarget());
-
     m_ui->comboBoxFramework->blockSignals(true);
+
+    //the current selected fw
+    QString fwText = m_ui->comboBoxFramework->currentText();
+
     m_ui->comboBoxFramework->clear();
-    m_ui->comboBoxFramework->addItems(UbuntuClickTool::getSupportedFrameworks(t));
+    m_ui->comboBoxFramework->addItems(UbuntuClickFrameworkProvider::getSupportedFrameworks());
+    selectFramework(fwText);
     m_ui->comboBoxFramework->blockSignals(false);
 }
 
+void UbuntuManifestEditorWidget::selectFramework (const QString &fw)
+{
+    // get the new Index for our new fw
+    int idx = m_ui->comboBoxFramework->findText(fw);
+
+    //if the framework name is not valid set to empty item
+    //just some data to easily find the unknown framework item without
+    //using string compare
+    if(idx < 0) {
+        if(m_ui->comboBoxFramework->findData(Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA) < 0)
+            m_ui->comboBoxFramework->addItem(tr(Constants::UBUNTU_UNKNOWN_FRAMEWORK_NAME),Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA);
+
+        m_ui->comboBoxFramework->setCurrentIndex(m_ui->comboBoxFramework->count()-1);
+    } else {
+        m_ui->comboBoxFramework->setCurrentIndex(idx);
+        m_ui->comboBoxFramework->removeItem(m_ui->comboBoxFramework->findData(Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA));
+    }
+}
+
 void UbuntuManifestEditorWidget::bzrChanged()
 {
     UbuntuBzr *bzr = UbuntuBzr::instance();
@@ -314,13 +319,19 @@
 {
     Core::DocumentModel *model = Core::EditorManager::documentModel();
 
+    //make sure all changes are in the manifest instance
+    syncToSource();
+
+    if(m_ui->comboBoxFramework->currentData() != Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA) {
+        int idx = m_ui->comboBoxFramework->findData(Constants::UBUNTU_UNKNOWN_FRAMEWORK_DATA);
+        if(idx >= 0)
+            m_ui->comboBoxFramework->removeItem(idx);
+    }
+
     QString v = policyForFramework(m_ui->comboBoxFramework->currentText());
     if(v.isEmpty())
         return;
 
-    //make sure all changes are in the manifest instance
-    syncToSource();
-
     QList<UbuntuClickManifest::Hook> hooks = m_manifest->hooks();
     foreach(const UbuntuClickManifest::Hook &hook, hooks){
         QFileInfo mFile(textEditorWidget()->baseTextDocument()->filePath());
@@ -464,12 +475,7 @@
 
                 if(debug) qDebug()<<"Setting to "<<bzr->whoami();
             } else if (i.key() == QStringLiteral("framework")) {
-                const UbuntuClickTool::Target *t = 0;
-                ProjectExplorer::Project *p = ProjectExplorer::SessionManager::startupProject();
-                if (p)
-                    t = UbuntuClickTool::clickTargetFromTarget(p->activeTarget());
-
-                targetObject.insert(i.key(),UbuntuClickTool::getMostRecentFramework( QString(), t));
+                targetObject.insert(i.key(),UbuntuClickFrameworkProvider::getMostRecentFramework( QString()));
             } else {
                 targetObject.insert(i.key(),i.value());
 

=== modified file 'src/ubuntu/ubuntumanifesteditorwidget.h'
--- src/ubuntu/ubuntumanifesteditorwidget.h	2014-08-19 06:15:32 +0000
+++ src/ubuntu/ubuntumanifesteditorwidget.h	2014-11-03 14:19:38 +0000
@@ -55,16 +55,17 @@
     bool syncToWidgets (UbuntuClickManifest *source);
     void syncToSource  ();
     QWidget *createMainWidget();
-    void updateFrameworkList ();    
     void addMissingFieldsToManifest(QString fileName);    
     QString policyForFramework(const QString &fw);
 
 protected slots:
     void bzrChanged ();
     void onFrameworkChanged ();
+    void updateFrameworkList ();
 
 private:
     QWidget *createHookWidget (const UbuntuClickManifest::Hook &hook);
+    void selectFramework(const QString &fw);
 
 private:
     Ui::UbuntuManifestEditor *m_ui;

=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-10-20 19:24:50 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-11-03 14:19:38 +0000
@@ -57,6 +57,7 @@
 #include <QtQml>
 #include <QFile>
 #include <coreplugin/icore.h>
+#include <stdint.h>
 
 using namespace Ubuntu;
 using namespace Ubuntu::Internal;
@@ -95,6 +96,8 @@
     if (!Core::MimeDatabase::addMimeTypes(mimetypesXml, errorString))
         return false;
 
+    addAutoReleasedObject(new UbuntuClickFrameworkProvider);
+
     m_ubuntuDeviceMode = new UbuntuDeviceMode();
     addAutoReleasedObject(m_ubuntuDeviceMode);