QVariant RequestManager::requestFileTransfer(QTcpSocket *& caller, QVariant params) { // VIDEO TRANSFER COMING SOON // get the video name QJsonObject jobject = params.toJsonObject(); QJsonValue file_name_value = jobject["FileName"]; QString file_name; if(file_name_value.isString()) file_name = file_name_value.toString(""); else { qDebug() << "VideoTransfer function passed invalid paramter VideoName: " << file_name_value; return QVariant(); } QFile file_in(file_name,this); qint64 file_size = file_in.size(); qDebug() << "Preparing to send file: " << file_name << " of size " << file_size; //get pointer to main ui object QWidget * mainwindow = qobject_cast<QWidget *>(parent()->parent()); // spwan off stream transfer video QAbstractSocket * caller_socket = qobject_cast< QAbstractSocket *>(caller); StreamTransferThread * file_transfer = new StreamTransferThread(qobject_cast<QObject *>(this),mainwindow, file_name,caller_socket,file_size); connect(file_transfer, &StreamTransferThread::finishedTransferingStream, this, &RequestManager::videoTransferThreadFinished); file_transfer->start(); return QVariant(); }
QVariant RequestManager::requestVideoList(QTcpSocket *caller, QVariant params) { QStringList videos; int max_return = -1; if(!params.isNull()) { // Get the packed max_return value QJsonObject max_return_obj(params.toJsonObject()); QJsonValue max_ret_val( max_return_obj["max_return"]); QVariant max_ret_var(max_ret_val.toVariant()); if(max_ret_var.type() == QVariant::Int) max_return = max_ret_var.toInt(); } videos = VideoLocator::findVideos(mVideoDirectory); if(max_return != -1) { int amount_to_remove = videos.length()-max_return; //only return the amount passed in for(int i = 0; i < amount_to_remove; ++i) { videos.pop_back(); } } QJsonObject ret_object; ret_object["VideoList"] = QJsonValue::fromVariant(QVariant::fromValue(videos)); QVariant ret_var(QVariant::fromValue(ret_object)); //qDebug() << "Sending back" << ret_var; return ret_var; }
void KNMusicStorePageAlbum::setPageLabel(int labelIndex, const QVariant &value) { //Check the lable index. switch(labelIndex) { case AlbumMetadata: { //This contains the basic data of the album. It is a pack of JSON type //object. QJsonObject metadata=value.toJsonObject(); // Album name, it should be a string type value. m_albumTitle->setText(metadata.value("name").toString()); // Album artist, it should be a string type value. m_albumArtistLabel->setText(metadata.value("artist").toString()); // Release date, it should be a long long type. UNIX timestamp. quint64 releaseTime=(quint64)metadata.value("release").toDouble(); m_releaseTime=QDateTime::fromMSecsSinceEpoch(releaseTime).date(); // Publish by, it should be a string type value. m_publishByLabel->setText(m_publishByText.arg( metadata.value("publish").toString())); // Song list, it is a JSON array. //Get the album model KNMusicStoreAlbumModel *albumModel=knMusicStoreGlobal->albumModel(); //Clear current data. albumModel->clear(); //Get the song list. QJsonArray songList=metadata.value("songs").toArray(); //Reset the size. albumModel->reserve(songList.size()); //Get over the list, construct the item. for(int i=0; i<songList.size(); ++i) { //Get the object. QJsonObject songItem=songList.at(i).toObject(); //Parse the item. KNMusicStoreSongInfo songInfo; songInfo.index=songItem.value("index").toString(); songInfo.name=songItem.value("name").toString(); songInfo.artist=songItem.value("artist").toString(); songInfo.artistId=songItem.value("artistId").toString(); songInfo.duration=songItem.value("duration").toString(); songInfo.customData=songItem.value("custom").toString(); //Set the song info to model. albumModel->replace(i, songInfo); } //Update the metadata. updateMetadata(); //Ask for show the page. emit requireShowPage(); emit requireSetNavigatorItem(PageAlbum, m_albumTitle->text()); //When this part is down. break; } case AlbumArt: //Parse the value as pixmap. m_albumArt->setPixmap(value.value<QPixmap>()); break; } }
QVariant RequestManager::requestVideoInfo(QTcpSocket *caller, QVariant params) { // Unpack the QVariant // Layers - QJsonObject { [ QJSonValue FuncName = "VideoInfo", QJSonValue VideoName = "video_passed"] } QJsonObject jobject = params.toJsonObject(); QJsonValue videoname_value = jobject["VideoName"]; QString videoname; if(videoname_value.isString()) videoname = videoname_value.toString(); else { qDebug() << "VideoInfo function passed invalid paramter VideoName: " << videoname_value; return QVariant(); } // fetched videoname now check if the info file exists //TODO Replace hard coded path with application settings manager variable VideoInfoReader * inforeader = new VideoInfoReader(this,"mediainfo", "//home/odroid/.config/MissionControl/media_info_format.txt"); // work some lambda magic Connect inforeader to the RequestManager, // when the media is fetched... call an inline "Slot" and pass name and info connect(inforeader, &VideoInfoReader::fetchedMediaInfo , [=](QString videoname, QString videoinfo) { // ... execute this inline lamdba function // disconnect the slot (don't need it anymore clean up) disconnect(inforeader, 0, this, 0); QJsonObject return_obj; return_obj["VideoName"] = videoname.remove("/home/odroid/Videos//"); return_obj["VideoInfo"] = videoinfo; // create a JsonDocument Wrapper = "{}" QJsonDocument doc; doc.setObject(return_obj); QByteArray message(doc.toJson()); // out to JSON // Prepend the Start Byte and Append the End Byte message.push_front("\001"); message.push_back("\004"); inforeader->deleteLater(); emit returnMessageReady(caller, message); }); inforeader->fetchMediaInfo(mVideoDirectory + "//" + videoname); return QVariant(); }
void onSnippetRequestSuccess(QVariant response) { qDebug() << "Got snippet info for video:" << _downloadData->videoId(); QVariantMap top = response.toJsonObject().toVariantMap(); Q_ASSERT(!top.isEmpty() && top.contains("items")); QList<QVariant> lst = top["items"].toList(); Q_ASSERT(!lst.empty() && lst.size() == 1); QVariantMap map = lst.at(0).toMap(); Q_ASSERT(!map.isEmpty() && map.contains("snippet") && map.contains("contentDetails")); QVariantMap snippet = map["snippet"].toMap(); Q_ASSERT(!snippet.isEmpty() && snippet.contains("thumbnails") && snippet.contains("title")); QVariantMap thumbnails = snippet["thumbnails"].toMap(); Q_ASSERT(!thumbnails.isEmpty() && thumbnails.contains("default")); QVariantMap contentDetails = map["contentDetails"].toMap(); Q_ASSERT(!contentDetails.isEmpty() && contentDetails.contains("duration")); QVariantMap quality; if (thumbnails.contains("high")) quality = thumbnails["high"].toMap(); else if (thumbnails.contains("medium")) quality = thumbnails["medium"].toMap(); else quality = thumbnails["default"].toMap(); QString url = quality["url"].toString(); setThumbnailUrl(QUrl(url)); _downloadData->setTitle(snippet["title"].toString()); _downloadData->setDuration(contentDetails["duration"].toString()); _snippetRequest->deleteLater(); _snippetRequest = NULL; beginDataDownloadsIfPossible(); }
void KNConfigure::setData(const QString &key, const QVariant &value) { //Check whether the value is null. if(value.isNull()) { //Remove the key from the configure data. m_dataObject.remove(key); //Complete. return; } //Because the QJsonObject can only insert QJsonValue, and the construct //function of QJsonValue only have the following types: // bool, QString, array, double, object. //So we have to translate some complex type variant to object. switch(value.type()) { //For the basic types(double, float, int, bool, QString), we will save them //directly. case QVariant::LongLong: m_dataObject.insert(key, value.toLongLong()); break; case QVariant::Double: m_dataObject.insert(key, value.toDouble()); break; case QVariant::String: m_dataObject.insert(key, value.toString()); break; case QVariant::Int: m_dataObject.insert(key, value.toInt()); break; case QVariant::Bool: m_dataObject.insert(key, value.toBool()); break; //For advanced types(like Font), we have to translate them to a object. case QVariant::Font: { //Generate the font object. QFont font=value.value<QFont>(); QJsonObject fontObject; fontObject.insert("Type", QString("Font")); fontObject.insert("Family", font.family()); fontObject.insert("Size", font.pixelSize()); fontObject.insert("Bold", font.bold()); fontObject.insert("Italic", font.italic()); fontObject.insert("Underline", font.underline()); fontObject.insert("Strikeout", font.strikeOut()); fontObject.insert("Kerning", font.kerning()); //Insert the font object. m_dataObject.insert(key, fontObject); break; } case QVariant::KeySequence: { //Generate a key sequence object. QKeySequence keySequence=value.value<QKeySequence>(); //A shortcut object. QJsonObject shortcutObject; shortcutObject.insert("Type", QString("Shortcut")); shortcutObject.insert("Key", keySequence.toString( QKeySequence::PortableText)); //Insert the key sequence object. m_dataObject.insert(key, shortcutObject); break; } //For the JSON object, it is quite wired that QVariant doesn't enumerate the //JSON type here, but it will use the meta type json object here. case QMetaType::QJsonObject: { //Check with the value contains the custom type. QJsonObject customObject=value.toJsonObject(); //Check the custom object type is matched. if("CustomObject"==customObject.value("Type").toString()) { //Simply insert the json object to the data. m_dataObject.insert(key, customObject); } break; } //For the JSON array, directly save the original data. case QMetaType::QJsonArray: { //Simply insert the json array to the data. m_dataObject.insert(key, value.toJsonArray()); break; } default: return; } //Emit the signal. emit valueChanged(); }