cascades

//MemoryCache.h
class MemoryCache
{
public:
    MemoryCache();
    ~MemoryCache();

    bool contains(const QUrl &url) const
        {
           return m_cache.contains(url);
        }
    QByteArray get(const QUrl &url) const
        {
           return m_cache[url];
        }
    void put(const QUrl &url, const QByteArray &data)
        {
           return m_cache[url] = data;
        }
    void clear()
        {
           return m_cache.clear();
        }

private:
    QHash<QUrl, QByteArray> m_cache;

};


//WebImageView.h
class WebImageView : public bb::cascades::ImageView {
    Q_OBJECT
    Q_PROPERTY(QUrl url READ getUrl WRITE setUrl NOTIFY urlChanged)
    Q_PROPERTY(double progress READ getProgress NOTIFY progressChanged)
    Q_PROPERTY(bool loading READ getLoading NOTIFY loadingChanged)
public:
    WebImageView(bb::cascades::Container * parent = 0);
    virtual ~WebImageView();

    static MemoryCache * cache();
    QUrl getUrl() const;
    void setUrl(const QUrl& url);
    double getProgress() const;
    bool getLoading() const;

signals:
        void urlChanged();
        void imageLoaded();
        void imageFailed();
        void loadingChanged();
        void progressChanged();
        void downloadFailed(QString error);

private slots:
    void onReplyFinished();
    void onDownloadProgress(qint64 bytes, qint64 total);
    void onProcessorFinished(const QImage &image);
    void onStateChanged(bb::cascades::ResourceState::Type);


private:
        static QScopedPointer<QNetworkAccessManager> m_network;
        static QScopedPointer<MemoryCache> m_cache;

        void setProgress(double progress);
        void setLoading(bool loading);

        QUrl m_url;
        ImageTracker *m_imageTracker;
        double m_progress;
        bool m_loading;
};

//WebImageView.cpp

QScopedPointer<MemoryCache> WebImageView::m_cache(new MemoryCache);
QScopedPointer<QNetworkAccessManager> WebImageView::m_network(new QNetworkAccessManager);

WebImageView::WebImageView(bb::cascades::Container * parent)
: bb::cascades::ImageView(parent),
  m_progress(0),
  m_loading(false),
  m_imageTracker(new ImageTracker(this))
{
    bool ret = connect(m_imageTracker,
               SIGNAL(stateChanged(bb::cascades::ResourceState::Type)),
               this,
               SLOT(onStateChanged(bb::cascades::ResourceState::Type)));

    Q_ASSERT(ret); Q_UNUSED(ret);
    this->setLoadEffect(bb::cascades::ImageViewLoadEffect::None);
}

WebImageView::~WebImageView() {
}

MemoryCache* WebImageView::cache()
{
    return m_cache.data();
}

QUrl WebImageView::getUrl() const
{
    return m_url;
}

double WebImageView::getProgress() const
{
    return m_progress;
}

bool WebImageView::getLoading() const
{
    return m_loading;
}

void WebImageView::setUrl(const QUrl &url)
{
    if (m_url != url) {
        m_url = url;
        emit urlChanged();
        m_progress = 0;

        this->resetImage();
        this->resetImageSource();

        if (m_cache->contains(url))
        {
            QByteArray data = m_cache->get(url);
            m_imageTracker->setImage(bb::cascades::Image(data));
            return;
        }

        setLoading(true);

        QNetworkRequest request;
        request.setUrl(m_url);

        QNetworkReply * reply = m_network->get(request);
        connect(reply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
        connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(onDownloadProgress(qint64,qint64)));

    }
}

void WebImageView::onReplyFinished() {
    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
    if (reply->error() == QNetworkReply::NoError)
    {
        qint64 bytesAvailable = reply->bytesAvailable();
        if (bytesAvailable > 0)
        {
            QByteArray data = reply->readAll();
            if (!m_cache->contains(m_url))
            {
                m_cache->put(m_url, data);
            }
                m_imageTracker->setImage(bb::cascades::Image(data));
        }
        else
        {
            emit downloadFailed(reply->errorString());
            m_progress = 0;
            setLoading(false);
        }
    }
    else
    {
        emit downloadFailed(reply->errorString());
        m_progress = 0;
        setLoading(false);
    }

    reply->deleteLater();
}

void WebImageView::onStateChanged(bb::cascades::ResourceState::Type state)
{
    if(state == ResourceState::Loaded)
    {
        this->setImage(m_imageTracker->image());
        setLoading(false);
        emit imageLoaded();
    }
    else if (state == ResourceState::ErrorInvalidFormat || state == ResourceState::ErrorMemory)
    {
     setLoading(false);
     emit imageFailed();
   }
}

void WebImageView::onDownloadProgress(qint64 bytes, qint64 total)
{
    setProgress((double)bytes/(double)total);
}

void WebImageView::setProgress(double progress)
{
    if (m_progress != progress)
    {
        m_progress = progress;
        emit progressChanged();
    }
}

void WebImageView::setLoading(bool loading)
{
    if (m_loading != loading)
    {
        m_loading = loading;
        emit loadingChanged();
    }
}