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();
}
