update

src/FluHttp.cpp

@@ -25,7 +25,7 @@ FluHttp::FluHttp(QObject *parent)
     timeout(15000);
     cacheMode(FluHttpType::CacheMode::NoCache);
     cacheDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)+"/httpcache");
-    breakPointDownload(true);
+    breakPointDownload(false);
 }
 
 FluHttp::~FluHttp(){
@@ -40,21 +40,18 @@ void FluHttp::cancel(){
     }
 }
 
-void FluHttp::handleReply(QNetworkReply* reply){
-    _cacheReply.append(reply);
-}
-
 void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
     QThreadPool::globalInstance()->start([=](){
-        QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"post")).toMap();
+        auto requestMap = toRequest(url,params,headers,"post");
+        QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
         Q_EMIT callable->start();
-        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
             Q_EMIT callable->finish();
             return;
         }
-        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
         }
         for (int i = 0; i < retry(); ++i) {
             QNetworkAccessManager manager;
@@ -84,17 +81,16 @@ void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> pa
             int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
             QString errorString = reply->errorString();
             bool isSuccess = reply->error() == QNetworkReply::NoError;
-            _cacheReply.removeOne(reply);
             reply->deleteLater();
             reply = nullptr;
             if (isSuccess) {
-                handleCache(data,result);
+                handleCache(requestMap,result);
                 Q_EMIT callable->success(result);
                 break;
             }else{
                 if(i == retry()-1){
-                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
-                        Q_EMIT callable->cache(readCache(data));
+                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
+                        Q_EMIT callable->cache(readCache(requestMap));
                     }
                     Q_EMIT callable->error(status,errorString,result);
                 }
@@ -106,15 +102,16 @@ void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> pa
 
 void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<QString, QVariant> headers){
     QThreadPool::globalInstance()->start([=](){
-        QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"postString")).toMap();
+        auto requestMap = toRequest(url,params,headers,"postString");
+        QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
         Q_EMIT callable->start();
-        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
             Q_EMIT callable->finish();
             return;
         }
-        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
         }
         for (int i = 0; i < retry(); ++i) {
             QNetworkAccessManager manager;
@@ -135,17 +132,16 @@ void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<
             int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
             QString errorString = reply->errorString();
             bool isSuccess = reply->error() == QNetworkReply::NoError;
-            _cacheReply.removeOne(reply);
             reply->deleteLater();
             reply = nullptr;
             if (isSuccess) {
-                handleCache(data,result);
+                handleCache(requestMap,result);
                 Q_EMIT callable->success(result);
                 break;
             }else{
                 if(i == retry()-1){
-                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
-                        Q_EMIT callable->cache(readCache(data));
+                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
+                        Q_EMIT callable->cache(readCache(requestMap));
                     }
                     Q_EMIT callable->error(status,errorString,result);
                 }
@@ -157,15 +153,16 @@ void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<
 
 void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
     QThreadPool::globalInstance()->start([=](){
-        QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"postJson")).toMap();
+        auto requestMap = toRequest(url,params,headers,"postJson");
+        QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
         Q_EMIT callable->start();
-        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
             Q_EMIT callable->finish();
             return;
         }
-        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
         }
         for (int i = 0; i < retry(); ++i) {
             QNetworkAccessManager manager;
@@ -186,17 +183,16 @@ void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant
             int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
             QString errorString = reply->errorString();
             bool isSuccess = reply->error() == QNetworkReply::NoError;
-            _cacheReply.removeOne(reply);
             reply->deleteLater();
             reply = nullptr;
             if (isSuccess) {
-                handleCache(data,result);
+                handleCache(requestMap,result);
                 Q_EMIT callable->success(result);
                 break;
             }else{
                 if(i == retry()-1){
-                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
-                        Q_EMIT callable->cache(readCache(data));
+                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
+                        Q_EMIT callable->cache(readCache(requestMap));
                     }
                     Q_EMIT callable->error(status,errorString,result);
                 }
@@ -208,13 +204,14 @@ void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant
 
 void FluHttp::get(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
     QThreadPool::globalInstance()->start([=](){
-        QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"get")).toMap();
+        auto requestMap = toRequest(url,params,headers,"get");
+        QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
         Q_EMIT callable->start();
-        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
         }
-        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
-            Q_EMIT callable->cache(readCache(data));
+        if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
+            Q_EMIT callable->cache(readCache(requestMap));
             Q_EMIT callable->finish();
             return;
         }
@@ -236,17 +233,16 @@ void FluHttp::get(QString url,HttpCallable* callable,QMap<QString, QVariant> par
             int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
             QString errorString = reply->errorString();
             bool isSuccess = reply->error() == QNetworkReply::NoError;
-            _cacheReply.removeOne(reply);
             reply->deleteLater();
             reply = nullptr;
             if (isSuccess) {
-                handleCache(data,result);
+                handleCache(requestMap,result);
                 Q_EMIT callable->success(result);
                 break;
             }else{
                 if(i == retry()-1){
-                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
-                        Q_EMIT callable->cache(readCache(data));
+                    if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
+                        Q_EMIT callable->cache(readCache(requestMap));
                     }
                     Q_EMIT callable->error(status,errorString,result);
                 }
@@ -268,17 +264,21 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
         QNetworkRequest request(_url);
         addHeaders(&request,data["headers"].toMap());
         QSharedPointer<QFile> file(new QFile(savePath));
+        QDir dir = QFileInfo(savePath).path();
+        if (!dir.exists(dir.path())){
+            dir.mkpath(dir.path());
+        }
         QEventLoop loop;
         connect(&manager,&QNetworkAccessManager::finished,&manager,[&loop](QNetworkReply *reply){
             loop.quit();
         });
-        auto filePath = getCacheFilePath(data);
         qint64 seek = 0;
+        auto filePath = getCacheFilePath(requestMap);
         QSharedPointer<QFile> fileCache(new QFile(filePath));
         if(fileCache->exists() && file->exists() && _breakPointDownload){
-            QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(data).toUtf8()).object();
-            auto fileSize = cacheInfo.value("fileSize").toInteger();
-            auto contentLength = cacheInfo.value("contentLength").toInteger();
+            QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(requestMap).toUtf8()).object();
+            qint64 fileSize = cacheInfo.value("fileSize").toDouble();
+            qint64 contentLength = cacheInfo.value("contentLength").toDouble();
             if(fileSize == contentLength && file->size() == contentLength){
                 Q_EMIT callable->downloadProgress(fileSize,contentLength);
                 Q_EMIT callable->success(savePath);
@@ -301,12 +301,12 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
         {
             qDebug()<<"FileCache Error";
         }
-        connect(reply,&QNetworkReply::readyRead,reply,[reply,file,fileCache,data,callable,seek]{
+        connect(reply,&QNetworkReply::readyRead,reply,[reply,file,fileCache,requestMap,callable,seek]{
             if (!reply || !file || reply->error() != QNetworkReply::NoError)
             {
                 return;
             }
-            QMap<QString, QVariant> downMap = data;
+            QMap<QString, QVariant> downMap = requestMap;
             qint64 contentLength = reply->header(QNetworkRequest::ContentLengthHeader).toLongLong()+seek;
             downMap.insert("contentLength",contentLength);
             QString eTag = reply->header(QNetworkRequest::ETagHeader).toString();
@@ -325,7 +325,6 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
         }else{
             Q_EMIT callable->error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString(),"");
         }
-        _cacheReply.removeOne(reply);
         reply->deleteLater();
         reply = nullptr;
         Q_EMIT callable->finish();
@@ -371,7 +370,6 @@ void FluHttp::upload(QString url,HttpCallable* callable,QMap<QString, QVariant>
         int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
         QString errorString = reply->errorString();
         bool isSuccess = reply->error() == QNetworkReply::NoError;
-        _cacheReply.removeOne(reply);
         reply->deleteLater();
         reply = nullptr;
         if (isSuccess) {
@@ -393,12 +391,12 @@ QMap<QString, QVariant> FluHttp::toRequest(const QString& url,const QVariant& pa
     return request;
 }
 
-QVariant FluHttp::invokeIntercept(QMap<QString, QVariant> request){
+QVariant FluHttp::invokeIntercept(QMap<QString, QVariant> request,Qt::ConnectionType type){
     if(!FluApp::getInstance()->httpInterceptor()){
         return request;
     }
     QVariant target;
-    QMetaObject::invokeMethod(FluApp::getInstance()->httpInterceptor(), "onIntercept",Qt::BlockingQueuedConnection,Q_RETURN_ARG(QVariant,target),Q_ARG(QVariant, request));
+    QMetaObject::invokeMethod(FluApp::getInstance()->httpInterceptor(), "onIntercept",type,Q_RETURN_ARG(QVariant,target),Q_ARG(QVariant, request));
     return target;
 }
 
@@ -463,3 +461,26 @@ void FluHttp::handleCache(QMap<QString, QVariant> request,const QString& result)
     }
     file->write(FluTools::getInstance()->toBase64(result).toUtf8());
 }
+
+qreal FluHttp::breakPointDownloadProgress(QString url,QString savePath,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
+    auto requestMap = toRequest(url,params,headers,"download");
+    requestMap.insert("savePath",savePath);
+    QSharedPointer<QFile> file(new QFile(savePath));
+    auto filePath = getCacheFilePath(requestMap);
+    QSharedPointer<QFile> fileCache(new QFile(filePath));
+    if(fileCache->exists() && file->exists() && _breakPointDownload){
+        QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(requestMap).toUtf8()).object();
+        double fileSize = cacheInfo.value("fileSize").toDouble();
+        double contentLength = cacheInfo.value("contentLength").toDouble();
+        if(fileSize == contentLength && file->size() == contentLength){
+            return 1;
+        }
+        if(fileSize==file->size()){
+            return fileSize/contentLength;
+        }else{
+            return 0;
+        }
+    }else{
+        return 0;
+    }
+}

src/FluHttp.h

@@ -32,9 +32,8 @@ class FluHttp : public QObject
     Q_PROPERTY_AUTO(bool,breakPointDownload);
     QML_NAMED_ELEMENT(FluHttp)
 private:
-    QVariant invokeIntercept(QMap<QString, QVariant> request);
+    QVariant invokeIntercept(QMap<QString, QVariant> request,Qt::ConnectionType type = Qt::BlockingQueuedConnection);
     QMap<QString, QVariant> toRequest(const QString& url,const QVariant& params,const QVariant& headers,const QString& method);
-    void handleReply(QNetworkReply* reply);
     void addQueryParam(QUrl* url,const QMap<QString, QVariant>& params);
     void addHeaders(QNetworkRequest* request,const QMap<QString, QVariant>& params);
     void handleCache(QMap<QString, QVariant> request, const QString& result);
@@ -51,6 +50,7 @@ public:
     Q_INVOKABLE void postJson(QString url,HttpCallable* callable,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
     Q_INVOKABLE void download(QString url,HttpCallable* callable,QString savePath,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
     Q_INVOKABLE void upload(QString url,HttpCallable* callable,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
+    Q_INVOKABLE qreal breakPointDownloadProgress(QString url,QString savePath,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
     Q_INVOKABLE void cancel();
 private:
     QList<QPointer<QNetworkReply>> _cacheReply;

src/FluTools.cpp

@@ -6,6 +6,7 @@
 #include <QScreen>
 #include <QColor>
 #include <QFileInfo>
+#include <QProcess>
 #include <QDir>
 #include <QCryptographicHash>
 #include <QTextDocument>
@@ -151,6 +152,27 @@ bool FluTools::removeDir(QString dirPath){
     return qDir.removeRecursively();
 }
 
+bool FluTools::removeFile(QString filePath){
+    QFile file(filePath);
+    return file.remove();
+}
+
 QString FluTools::sha256(QString text){
     return QCryptographicHash::hash(text.toUtf8(), QCryptographicHash::Sha256).toHex();
 }
+
+void FluTools::showFileInFolder(QString path){
+#if defined(Q_OS_WIN)
+    QProcess::startDetached("explorer.exe", {"/select,", QDir::toNativeSeparators(path)});
+#endif
+#if defined(Q_OS_LINUX)
+    QFileInfo fileInfo(path);
+    auto process = "xdg-open";
+    auto arguments = { fileInfo.absoluteDir().absolutePath() };
+    QProcess::startDetached(process, arguments);
+#endif
+#if defined(Q_OS_MACOS)
+    QProcess::execute("/usr/bin/osascript", {"-e", "tell application \"Finder\" to reveal POSIX file \"" + path + "\""});
+    QProcess::execute("/usr/bin/osascript", {"-e", "tell application \"Finder\" to activate"});
+#endif
+}

src/FluTools.h

@@ -180,6 +180,19 @@ public:
      */
     Q_INVOKABLE bool removeDir(QString dirPath);
 
+    /**
+     * @brief removeFile
+     * @param filePath
+     * @return
+     */
+    Q_INVOKABLE bool removeFile(QString filePath);
+
+    /**
+     * @brief showFileInFolder
+     * @param path
+     */
+    Q_INVOKABLE void showFileInFolder(QString path);
+
 };
 
 #endif // FLUTOOLS_H

src/Qt5/imports/FluentUI/plugins.qmltypes

@@ -8,21 +8,6 @@ import QtQuick.tooling 1.2
 
 Module {
     dependencies: ["QtQuick 2.0"]
-	Component {
-        name: "FluHttpType"
-        exports: ["FluentUI/FluHttpType 1.0"]
-        isCreatable: false
-        exportMetaObjectRevisions: [0]
-        Enum {
-            name: "CacheMode"
-            values: {
-                "NoCache": 0,
-                "RequestFailedReadCache": 1,
-                "IfNoneCacheRequest": 2,
-				"FirstCacheThenRequest": 4
-            }
-        }
-    }
     Component {
         name: "FluCalendarViewType"
         exports: ["FluentUI/FluCalendarViewType 1.0"]
@@ -85,116 +70,140 @@ Module {
         exportMetaObjectRevisions: [0]
         Property { name: "retry"; type: "int" }
         Property { name: "timeout"; type: "int" }
+        Property { name: "cacheMode"; type: "int" }
+        Property { name: "cacheDir"; type: "string" }
+        Property { name: "breakPointDownload"; type: "bool" }
         Method {
             name: "get"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "get"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
         }
         Method {
             name: "get"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
         }
         Method {
             name: "post"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "post"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
         }
         Method {
             name: "post"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
         }
         Method {
             name: "postString"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "string" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "postString"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "string" }
         }
         Method {
             name: "postString"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
         }
         Method {
             name: "postJson"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "postJson"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
         }
         Method {
             name: "postJson"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
         }
         Method {
             name: "download"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
-            Parameter { name: "filePath"; type: "string" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
+            Parameter { name: "savePath"; type: "string" }
             Parameter { name: "params"; type: "QVariantMap" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "download"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
-            Parameter { name: "filePath"; type: "string" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
+            Parameter { name: "savePath"; type: "string" }
             Parameter { name: "params"; type: "QVariantMap" }
         }
         Method {
             name: "download"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
-            Parameter { name: "filePath"; type: "string" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
+            Parameter { name: "savePath"; type: "string" }
         }
         Method {
             name: "upload"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
             Parameter { name: "headers"; type: "QVariantMap" }
         }
         Method {
             name: "upload"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
             Parameter { name: "params"; type: "QVariantMap" }
         }
         Method {
             name: "upload"
             Parameter { name: "url"; type: "string" }
-            Parameter { name: "callable"; type: "QJSValue" }
+            Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
+        }
+        Method {
+            name: "breakPointDownloadProgress"
+            type: "double"
+            Parameter { name: "url"; type: "string" }
+            Parameter { name: "savePath"; type: "string" }
+            Parameter { name: "params"; type: "QVariantMap" }
+            Parameter { name: "headers"; type: "QVariantMap" }
+        }
+        Method {
+            name: "breakPointDownloadProgress"
+            type: "double"
+            Parameter { name: "url"; type: "string" }
+            Parameter { name: "savePath"; type: "string" }
+            Parameter { name: "params"; type: "QVariantMap" }
+        }
+        Method {
+            name: "breakPointDownloadProgress"
+            type: "double"
+            Parameter { name: "url"; type: "string" }
+            Parameter { name: "savePath"; type: "string" }
         }
         Method { name: "cancel" }
     }
@@ -204,6 +213,21 @@ Module {
         exports: ["FluentUI/FluHttpInterceptor 1.0"]
         exportMetaObjectRevisions: [0]
     }
+    Component {
+        name: "FluHttpType"
+        exports: ["FluentUI/FluHttpType 1.0"]
+        isCreatable: false
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "CacheMode"
+            values: {
+                "NoCache": 0,
+                "RequestFailedReadCache": 1,
+                "IfNoneCacheRequest": 2,
+                "FirstCacheThenRequest": 4
+            }
+        }
+    }
     Component {
         name: "FluNavigationViewType"
         exports: ["FluentUI/FluNavigationViewType 1.0"]
@@ -241,7 +265,7 @@ Module {
             }
         }
     }
-	Component {
+    Component {
         name: "FluScreenshotType"
         exports: ["FluentUI/FluScreenshotType 1.0"]
         isCreatable: false
@@ -253,20 +277,6 @@ Module {
                 "File": 1
             }
         }
-    }
-	Component {
-        name: "FluTimelineType"
-        exports: ["FluentUI/FluTimelineType 1.0"]
-        isCreatable: false
-        exportMetaObjectRevisions: [0]
-        Enum {
-            name: "Mode"
-            values: {
-                "Left": 0,
-                "Right": 1,
-				"Alternate": 2
-            }
-        }
     }
     Component {
         name: "FluStatusViewType"
@@ -332,6 +342,20 @@ Module {
             }
         }
     }
+    Component {
+        name: "FluTimelineType"
+        exports: ["FluentUI/FluTimelineType 1.0"]
+        isCreatable: false
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "Mode"
+            values: {
+                "Left": 0,
+                "Right": 1,
+                "Alternate": 2
+            }
+        }
+    }
     Component {
         name: "FluTreeViewType"
         exports: ["FluentUI/FluTreeViewType 1.0"]
@@ -1787,6 +1811,38 @@ Module {
             }
         }
     }
+    Component {
+        name: "HttpCallable"
+        prototype: "QObject"
+        exports: ["FluentUI/HttpCallable 1.0"]
+        exportMetaObjectRevisions: [0]
+        Signal { name: "start" }
+        Signal { name: "finish" }
+        Signal {
+            name: "error"
+            Parameter { name: "status"; type: "int" }
+            Parameter { name: "errorString"; type: "string" }
+            Parameter { name: "result"; type: "string" }
+        }
+        Signal {
+            name: "success"
+            Parameter { name: "result"; type: "string" }
+        }
+        Signal {
+            name: "cache"
+            Parameter { name: "result"; type: "string" }
+        }
+        Signal {
+            name: "downloadProgress"
+            Parameter { name: "recv"; type: "qlonglong" }
+            Parameter { name: "total"; type: "qlonglong" }
+        }
+        Signal {
+            name: "uploadProgress"
+            Parameter { name: "recv"; type: "qlonglong" }
+            Parameter { name: "total"; type: "qlonglong" }
+        }
+    }
     Component {
         name: "QRCode"
         defaultProperty: "data"
@@ -1816,6 +1872,7 @@ Module {
         exportMetaObjectRevisions: [0]
         Property { name: "saveFolder"; type: "string" }
         Property { name: "captureMode"; type: "int" }
+        Property { name: "hitDrawData"; type: "DrawData"; isPointer: true }
         Signal {
             name: "captrueToPixmapCompleted"
             Parameter { name: "captrue"; type: "QPixmap" }
@@ -1829,6 +1886,25 @@ Module {
             Parameter { name: "start"; type: "QPoint" }
             Parameter { name: "end"; type: "QPoint" }
         }
+        Method {
+            name: "appendDrawData"
+            type: "DrawData*"
+            Parameter { name: "drawType"; type: "int" }
+            Parameter { name: "start"; type: "QPoint" }
+            Parameter { name: "end"; type: "QPoint" }
+        }
+        Method {
+            name: "updateDrawData"
+            Parameter { name: "data"; type: "DrawData"; isPointer: true }
+            Parameter { name: "start"; type: "QPoint" }
+            Parameter { name: "end"; type: "QPoint" }
+        }
+        Method { name: "clear" }
+        Method {
+            name: "hit"
+            type: "DrawData*"
+            Parameter { name: "point"; type: "QPoint" }
+        }
     }
     Component {
         name: "WindowHelper"