easthighNerd/qcma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added a bunch of warning flags and fixed most of the shadowed

Browse Source 
variables.
This commit is contained in:
codestation
2015-02-27 22:59:22 -04:30
parent ddf9b4a611
commit 60a3049391
37 changed files with 380 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
qcma_appindicator.pro
View File

@@ -18,6 +18,14 @@ HEADERS += \
src/indicator/trayindicator.h \ src/indicator/trayindicator.h \
src/indicator/unityindicator.h src/indicator/unityindicator.h
CXXFLAGS_WARNINGS = -Wall -Wextra -Wshadow -Wcast-align -Wctor-dtor-privacy \
-Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-declarations \
-Wmissing-include-dirs -Woverloaded-virtual -Wredundant-decls \
-Wstrict-overflow=5 -Wundef -Wno-unused -Wno-missing-field-initializers \
-Wno-format-nonliteral
QMAKE_CXXFLAGS += -Wno-write-strings -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS $$CXXFLAGS_WARNINGS
DATADIR = $$PREFIX/share DATADIR = $$PREFIX/share
actions64.path = $$DATADIR/icons/hicolor/64x64/actions actions64.path = $$DATADIR/icons/hicolor/64x64/actions

8
qcma_common.pri
View File

@@ -58,8 +58,14 @@ RESOURCES += qcmares.qrc translations.qrc
CONFIG += link_pkgconfig CONFIG += link_pkgconfig
PKGCONFIG = libvitamtp libavformat libavcodec libavutil libswscale PKGCONFIG = libvitamtp libavformat libavcodec libavutil libswscale
CXXFLAGS_WARNINGS = -Wall -Wextra -Wshadow -Wcast-align -Wctor-dtor-privacy \
-Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-declarations \
-Wmissing-include-dirs -Woverloaded-virtual -Wredundant-decls \
-Wstrict-overflow=5 -Wundef -Wno-unused -Wno-missing-field-initializers \
-Wno-format-nonliteral
# custom CXXFLAGS # custom CXXFLAGS
QMAKE_CXXFLAGS += -Wno-write-strings -Wall -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS QMAKE_CXXFLAGS += -Wno-write-strings -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS $$CXXFLAGS_WARNINGS
#Linux-only config #Linux-only config
unix:!macx { unix:!macx {

8
qcma_kdenotifier.pro
View File

@@ -25,6 +25,14 @@ HEADERS += \
src/indicator/kdenotifier.h \ src/indicator/kdenotifier.h \
src/indicator/kdenotifiertray.h src/indicator/kdenotifiertray.h
CXXFLAGS_WARNINGS = -Wall -Wextra -Wshadow -Wcast-align -Wctor-dtor-privacy \
-Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-declarations \
-Wmissing-include-dirs -Woverloaded-virtual -Wredundant-decls \
-Wstrict-overflow=5 -Wundef -Wno-unused -Wno-missing-field-initializers \
-Wno-format-nonliteral
QMAKE_CXXFLAGS += -Wno-write-strings -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS $$CXXFLAGS_WARNINGS
target.path = /usr/lib/qcma target.path = /usr/lib/qcma
INSTALLS += target INSTALLS += target

6
src/avdecoder.cpp
View File

@@ -142,7 +142,7 @@ QByteArray AVDecoder::getAudioThumbnail(int width, int height)
return data; return data;
} }
AVFrame *AVDecoder::getDecodedFrame(AVCodecContext *pCodecCtx, int stream_index) AVFrame *AVDecoder::getDecodedFrame(AVCodecContext *codec_ctx, int frame_stream_index)
{ {
AVFrame *pFrame = avcodec_alloc_frame(); AVFrame *pFrame = avcodec_alloc_frame();
@@ -150,8 +150,8 @@ AVFrame *AVDecoder::getDecodedFrame(AVCodecContext *pCodecCtx, int stream_index)
int frame_finished = 0; int frame_finished = 0;
while(!frame_finished && av_read_frame(pFormatCtx, &packet)>=0) { while(!frame_finished && av_read_frame(pFormatCtx, &packet)>=0) {
if(packet.stream_index == stream_index) { if(packet.stream_index == frame_stream_index) {
avcodec_decode_video2(pCodecCtx, pFrame, &frame_finished, &packet); avcodec_decode_video2(codec_ctx, pFrame, &frame_finished, &packet);
} }
av_free_packet(&packet); av_free_packet(&packet);
} }

4
src/cli/headlessmanager.cpp
View File

@@ -28,8 +28,8 @@
#include <QSettings> #include <QSettings>
#include <vitamtp.h> #include <vitamtp.h>
HeadlessManager::HeadlessManager(QObject *parent) : HeadlessManager::HeadlessManager(QObject *obj_parent) :
QObject(parent), dbus_conn(QDBusConnection::sessionBus()) QObject(obj_parent), dbus_conn(QDBusConnection::sessionBus())
{ {
new HeadlessManagerAdaptor(this); new HeadlessManagerAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus(); QDBusConnection dbus = QDBusConnection::sessionBus();

4
src/cli/main_cli.cpp
View File

@@ -36,11 +36,11 @@
#include "headlessmanager.h" #include "headlessmanager.h"
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
void noMessageOutput(QtMsgType type, const QMessageLogContext &, const QString & str) static void noMessageOutput(QtMsgType type, const QMessageLogContext &, const QString & str)
{ {
const char * msg = str.toStdString().c_str(); const char * msg = str.toStdString().c_str();
#else #else
void noMessageOutput(QtMsgType type, const char *msg) static void noMessageOutput(QtMsgType type, const char *msg)
{ {
#endif #endif
Q_UNUSED(type); Q_UNUSED(type);

10
src/cmabroadcast.cpp
View File

@@ -44,8 +44,8 @@ const char *CmaBroadcast::broadcast_query_end = " * HTTP/1.1\r\n";
const char *CmaBroadcast::broadcast_ok = "HTTP/1.1 200 OK"; const char *CmaBroadcast::broadcast_ok = "HTTP/1.1 200 OK";
const char *CmaBroadcast::broadcast_unavailable = "HTTP/1.1 503 NG"; const char *CmaBroadcast::broadcast_unavailable = "HTTP/1.1 503 NG";
CmaBroadcast::CmaBroadcast(QObject *parent) : CmaBroadcast::CmaBroadcast(QObject *obj_parent) :
QObject(parent) QObject(obj_parent)
{ {
QSettings settings; QSettings settings;
// generate a GUID if doesn't exist yet in settings // generate a GUID if doesn't exist yet in settings
@@ -69,14 +69,14 @@ void CmaBroadcast::readPendingDatagrams()
QByteArray datagram; QByteArray datagram;
datagram.resize(socket->pendingDatagramSize()); datagram.resize(socket->pendingDatagramSize());
QHostAddress sender; QHostAddress cma_sender;
quint16 senderPort; quint16 senderPort;
socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); socket->readDatagram(datagram.data(), datagram.size(), &cma_sender, &senderPort);
if(datagram.startsWith(broadcast_query_start) && datagram.contains(broadcast_query_end)) { if(datagram.startsWith(broadcast_query_start) && datagram.contains(broadcast_query_end)) {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
socket->writeDatagram(reply, sender, senderPort); socket->writeDatagram(reply, cma_sender, senderPort);
} else { } else {
qWarning("Unknown request: %.*s\n", datagram.length(), datagram.constData()); qWarning("Unknown request: %.*s\n", datagram.length(), datagram.constData());
} }

36
src/cmaclient.cpp
View File

@@ -44,15 +44,15 @@ bool CmaClient::in_progress = false;
CmaClient *CmaClient::this_object = NULL; CmaClient *CmaClient::this_object = NULL;
CmaClient::CmaClient(Database *db, QObject *parent) : CmaClient::CmaClient(Database *db, QObject *obj_parent) :
QObject(parent), m_db(db), m_broadcast(NULL) QObject(obj_parent), m_db(db), m_broadcast(NULL)
{ {
this_object = this; this_object = this;
} }
CmaClient::CmaClient(Database *db, CmaBroadcast *broadcast, QObject *parent) : CmaClient::CmaClient(Database *db, CmaBroadcast *broadcast, QObject *obj_parent) :
QObject(parent), m_db(db), m_broadcast(broadcast) QObject(obj_parent), m_db(db), m_broadcast(broadcast)
{ {
this_object = this; this_object = this;
} }
@@ -195,46 +195,46 @@ int CmaClient::generatePin(wireless_vita_info_t *info, int *p_err)
void CmaClient::enterEventLoop(vita_device_t *device) void CmaClient::enterEventLoop(vita_device_t *device)
{ {
vita_event_t event; vita_event_t obj_event;
qDebug("Starting event loop"); qDebug("Starting event loop");
CmaEvent eventLoop(m_db, device); CmaEvent eventLoop(m_db, device);
QThread thread; QThread obj_thread;
thread.setObjectName("event_thread"); obj_thread.setObjectName("event_thread");
eventLoop.moveToThread(&thread); eventLoop.moveToThread(&obj_thread);
connect(&thread, SIGNAL(started()), &eventLoop, SLOT(process())); connect(&obj_thread, SIGNAL(started()), &eventLoop, SLOT(process()));
connect(&eventLoop, SIGNAL(refreshDatabase()), this, SIGNAL(refreshDatabase()), Qt::DirectConnection); connect(&eventLoop, SIGNAL(refreshDatabase()), this, SIGNAL(refreshDatabase()), Qt::DirectConnection);
connect(&eventLoop, SIGNAL(finishedEventLoop()), &thread, SLOT(quit()), Qt::DirectConnection); connect(&eventLoop, SIGNAL(finishedEventLoop()), &obj_thread, SLOT(quit()), Qt::DirectConnection);
connect(&eventLoop, SIGNAL(messageSent(QString)), this, SIGNAL(messageSent(QString)), Qt::DirectConnection); connect(&eventLoop, SIGNAL(messageSent(QString)), this, SIGNAL(messageSent(QString)), Qt::DirectConnection);
thread.start(); obj_thread.start();
while(isActive()) { while(isActive()) {
if(VitaMTP_Read_Event(device, &event) < 0) { if(VitaMTP_Read_Event(device, &obj_event) < 0) {
qWarning("Error reading event from Vita."); qWarning("Error reading event from Vita.");
break; break;
} }
// do not create a event for this since there aren't more events to read // do not create a event for this since there aren't more events to read
if(event.Code == PTP_EC_VITA_RequestTerminate) { if(obj_event.Code == PTP_EC_VITA_RequestTerminate) {
qDebug("Terminating event thread"); qDebug("Terminating event thread");
break; break;
// this one shuold be processed inmediately // this one shuold be processed inmediately
} else if(event.Code == PTP_EC_VITA_RequestCancelTask) { } else if(obj_event.Code == PTP_EC_VITA_RequestCancelTask) {
eventLoop.vitaEventCancelTask(&event, event.Param1); eventLoop.vitaEventCancelTask(&obj_event, obj_event.Param1);
qDebug("Ended event, code: 0x%x, id: %d", event.Code, event.Param1); qDebug("Ended event, code: 0x%x, id: %d", obj_event.Code, obj_event.Param1);
continue; continue;
} }
// the events are processed synchronously except for cancel/terminate // the events are processed synchronously except for cancel/terminate
qDebug("Sending new event"); qDebug("Sending new event");
eventLoop.setEvent(event); eventLoop.setEvent(obj_event);
} }
eventLoop.stop(); eventLoop.stop();
thread.wait(); obj_thread.wait();
qDebug("Finishing event loop"); qDebug("Finishing event loop");
} }

4
src/cmaclient.h
View File

@@ -35,8 +35,8 @@ class CmaClient : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit CmaClient(Database *db, QObject *parent = 0); explicit CmaClient(Database *db, QObject *obj_parent = 0);
explicit CmaClient(Database *db, CmaBroadcast *broadcast, QObject *parent = 0); explicit CmaClient(Database *db, CmaBroadcast *broadcast, QObject *obj_parent = 0);
static bool isRunning(); static bool isRunning();
void launch(); void launch();

339
src/cmaevent.cpp
View File

@@ -33,7 +33,7 @@ QFile *CmaEvent::m_file = NULL;
static metadata_t g_thumbmeta = {0, 0, 0, NULL, NULL, 0, 0, 0, Thumbnail, {{17, 240, 136, 0, 1, 1.0f, 2}}, NULL}; static metadata_t g_thumbmeta = {0, 0, 0, NULL, NULL, 0, 0, 0, Thumbnail, {{17, 240, 136, 0, 1, 1.0f, 2}}, NULL};
CmaEvent::CmaEvent(Database *db, vita_device_t *s_device) : CmaEvent::CmaEvent(Database *db, vita_device_t *s_device) :
device(s_device), m_db(db), is_active(true) m_device(s_device), m_db(db), is_active(true)
{ {
} }
@@ -46,9 +46,9 @@ void CmaEvent::process()
if(!isActive()) { if(!isActive()) {
break; break;
} }
mutex.lock();
QMutexLocker locker(&mutex);
processEvent(); processEvent();
mutex.unlock();
} }
qDebug("Finishing event_thread"); qDebug("Finishing event_thread");
emit finishedEventLoop(); emit finishedEventLoop();
@@ -70,81 +70,81 @@ void CmaEvent::stop()
void CmaEvent::setDevice(vita_device_t *device) void CmaEvent::setDevice(vita_device_t *device)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
this->device = device; m_device = device;
} }
void CmaEvent::setEvent(vita_event_t event) void CmaEvent::setEvent(vita_event_t cma_event)
{ {
mutex.lock(); QMutexLocker locker(&mutex);
this->t_event = event; m_event = cma_event;
mutex.unlock(); locker.unlock();
sema.release(); sema.release();
} }
void CmaEvent::processEvent() void CmaEvent::processEvent()
{ {
switch(t_event.Code) { switch(m_event.Code) {
case PTP_EC_VITA_RequestSendNumOfObject: case PTP_EC_VITA_RequestSendNumOfObject:
vitaEventSendNumOfObject(&t_event, t_event.Param1); vitaEventSendNumOfObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendObjectMetadata: case PTP_EC_VITA_RequestSendObjectMetadata:
vitaEventSendObjectMetadata(&t_event, t_event.Param1); vitaEventSendObjectMetadata(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendObject: case PTP_EC_VITA_RequestSendObject:
vitaEventSendObject(&t_event, t_event.Param1); vitaEventSendObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendHttpObjectFromURL: case PTP_EC_VITA_RequestSendHttpObjectFromURL:
vitaEventSendHttpObjectFromURL(&t_event, t_event.Param1); vitaEventSendHttpObjectFromURL(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_Unknown1: // unimplemented case PTP_EC_VITA_Unknown1: // unimplemented
vitaEventUnimplementated(&t_event, t_event.Param1); vitaEventUnimplementated(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendObjectStatus: case PTP_EC_VITA_RequestSendObjectStatus:
vitaEventSendObjectStatus(&t_event, t_event.Param1); vitaEventSendObjectStatus(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendObjectThumb: case PTP_EC_VITA_RequestSendObjectThumb:
vitaEventSendObjectThumb(&t_event, t_event.Param1); vitaEventSendObjectThumb(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestDeleteObject: case PTP_EC_VITA_RequestDeleteObject:
vitaEventDeleteObject(&t_event, t_event.Param1); vitaEventDeleteObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestGetSettingInfo: case PTP_EC_VITA_RequestGetSettingInfo:
vitaEventGetSettingInfo(&t_event, t_event.Param1); vitaEventGetSettingInfo(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendHttpObjectPropFromURL: case PTP_EC_VITA_RequestSendHttpObjectPropFromURL:
vitaEventSendHttpObjectPropFromURL(&t_event, t_event.Param1); vitaEventSendHttpObjectPropFromURL(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendPartOfObject: case PTP_EC_VITA_RequestSendPartOfObject:
vitaEventSendPartOfObject(&t_event, t_event.Param1); vitaEventSendPartOfObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestOperateObject: case PTP_EC_VITA_RequestOperateObject:
vitaEventOperateObject(&t_event, t_event.Param1); vitaEventOperateObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestGetPartOfObject: case PTP_EC_VITA_RequestGetPartOfObject:
vitaEventGetPartOfObject(&t_event, t_event.Param1); vitaEventGetPartOfObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendStorageSize: case PTP_EC_VITA_RequestSendStorageSize:
vitaEventSendStorageSize(&t_event, t_event.Param1); vitaEventSendStorageSize(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestCheckExistance: case PTP_EC_VITA_RequestCheckExistance:
vitaEventCheckExistance(&t_event, t_event.Param1); vitaEventCheckExistance(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestGetTreatObject: case PTP_EC_VITA_RequestGetTreatObject:
vitaEventGetTreatObject(&t_event, t_event.Param1); vitaEventGetTreatObject(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendCopyConfirmationInfo: case PTP_EC_VITA_RequestSendCopyConfirmationInfo:
vitaEventSendCopyConfirmationInfo(&t_event, t_event.Param1); vitaEventSendCopyConfirmationInfo(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendObjectMetadataItems: case PTP_EC_VITA_RequestSendObjectMetadataItems:
vitaEventSendObjectMetadataItems(&t_event, t_event.Param1); vitaEventSendObjectMetadataItems(&m_event, m_event.Param1);
break; break;
case PTP_EC_VITA_RequestSendNPAccountInfo: case PTP_EC_VITA_RequestSendNPAccountInfo:
vitaEventSendNPAccountInfo(&t_event, t_event.Param1); vitaEventSendNPAccountInfo(&m_event, m_event.Param1);
break; break;
default: default:
vitaEventUnimplementated(&t_event, t_event.Param1); vitaEventUnimplementated(&m_event, m_event.Param1);
} }
qDebug("Ended event, code: 0x%x, id: %d", t_event.Code, t_event.Param1); qDebug("Ended event, code: 0x%x, id: %d", m_event.Code, m_event.Param1);
} }
quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle) quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle)
@@ -156,13 +156,13 @@ quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle)
quint32 *p_handles; quint32 *p_handles;
unsigned int p_len; unsigned int p_len;
if(VitaMTP_GetObject_Info(device, handle, &name, &dataType) != PTP_RC_OK) { if(VitaMTP_GetObject_Info(m_device, handle, &name, &dataType) != PTP_RC_OK) {
qWarning("Cannot get object for handle %d", handle); qWarning("Cannot get object for handle %d", handle);
return PTP_RC_VITA_Invalid_Data; return PTP_RC_VITA_Invalid_Data;
} }
if(dataType & Folder) { if(dataType & Folder) {
if(VitaMTP_GetObject_Folder(device, handle, &p_handles, &p_len) != PTP_RC_OK) { if(VitaMTP_GetObject_Folder(m_device, handle, &p_handles, &p_len) != PTP_RC_OK) {
qWarning("Cannot get folder handles for handle %d", handle); qWarning("Cannot get folder handles for handle %d", handle);
return PTP_RC_VITA_Invalid_Data; return PTP_RC_VITA_Invalid_Data;
} }
@@ -200,7 +200,7 @@ quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle)
// the size gets ignored because we can also get it via info.size() // the size gets ignored because we can also get it via info.size()
uint64_t size; uint64_t size;
VitaMTP_GetObject_Callback(device, handle, &size, CmaEvent::writeCallback); VitaMTP_GetObject_Callback(m_device, handle, &size, CmaEvent::writeCallback);
m_file->close(); m_file->close();
delete m_file; delete m_file;
} }
@@ -229,13 +229,13 @@ quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle)
return PTP_RC_OK; return PTP_RC_OK;
} }
void CmaEvent::vitaEventGetTreatObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventGetTreatObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
treat_object_t treatObject; treat_object_t treatObject;
if(VitaMTP_GetTreatObject(device, eventId, &treatObject) != PTP_RC_OK) { if(VitaMTP_GetTreatObject(m_device, eventId, &treatObject) != PTP_RC_OK) {
qWarning("Cannot get information on object to get"); qWarning("Cannot get information on object to get");
return; return;
} }
@@ -246,19 +246,19 @@ void CmaEvent::vitaEventGetTreatObject(vita_event_t *event, int eventId)
if(!m_db->getObjectMetadata(treatObject.ohfiParent, metadata)) { if(!m_db->getObjectMetadata(treatObject.ohfiParent, metadata)) {
qWarning("Cannot find parent OHFI %d", treatObject.ohfiParent); qWarning("Cannot find parent OHFI %d", treatObject.ohfiParent);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} }
VitaMTP_ReportResult(device, eventId, processAllObjects(metadata, treatObject.handle)); VitaMTP_ReportResult(m_device, eventId, processAllObjects(metadata, treatObject.handle));
} }
void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
copy_confirmation_info_t *info; copy_confirmation_info_t *info;
if(VitaMTP_SendCopyConfirmationInfoInit(device, eventId, &info) != PTP_RC_OK) { if(VitaMTP_SendCopyConfirmationInfoInit(m_device, eventId, &info) != PTP_RC_OK) {
qWarning("Error recieving initial information."); qWarning("Error recieving initial information.");
return; return;
} }
@@ -269,33 +269,33 @@ void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *event, int eventI
// check if the item is a single folder // check if the item is a single folder
if(info->count == 1) { if(info->count == 1) {
metadata_t meta; metadata_t obj_meta;
if(m_db->getObjectMetadata(info->ohfi[0], meta)) { if(m_db->getObjectMetadata(info->ohfi[0], obj_meta)) {
// got a folder // got a folder
if(meta.dataType & Folder) { if(obj_meta.dataType & Folder) {
metadata_t *meta_list = NULL; metadata_t *meta_list = NULL;
if(m_db->getObjectList(info->ohfi[0], &meta_list)) { if(m_db->getObjectList(info->ohfi[0], &meta_list)) {
int count = 0; int count = 0;
metadata_t *meta = meta_list; metadata_t *single_meta = meta_list;
// count files // count files
while(meta) { while(single_meta) {
if(meta->dataType & File) { if(single_meta->dataType & File) {
count++; count++;
} }
meta = meta->next_metadata; single_meta = single_meta->next_metadata;
} }
// create struct to hold all the file identifiers // create struct to hold all the file identifiers
info = (copy_confirmation_info_t *)malloc(sizeof(uint32_t) * count + sizeof(copy_confirmation_info_t)); info = (copy_confirmation_info_t *)malloc(sizeof(uint32_t) * count + sizeof(copy_confirmation_info_t));
meta = meta_list; single_meta = meta_list;
info->count = 0; info->count = 0;
// copy all the file ohfi // copy all the file ohfi
while(meta) { while(single_meta) {
if(meta->dataType & File) { if(single_meta->dataType & File) {
info->ohfi[info->count] = meta->ohfi; info->ohfi[info->count] = single_meta->ohfi;
total_size += meta->size; total_size += single_meta->size;
info->count++; info->count++;
} }
meta = meta->next_metadata; single_meta = single_meta->next_metadata;
} }
} }
@@ -316,21 +316,21 @@ void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *event, int eventI
} }
} }
if(VitaMTP_SendCopyConfirmationInfo(device, eventId, info, total_size) != PTP_RC_OK) { if(VitaMTP_SendCopyConfirmationInfo(m_device, eventId, info, total_size) != PTP_RC_OK) {
qWarning("Error sending copy confirmation"); qWarning("Error sending copy confirmation");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
free(info); free(info);
} }
void CmaEvent::vitaEventSendObjectMetadataItems(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendObjectMetadataItems(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
quint32 ohfi; quint32 ohfi;
if(VitaMTP_SendObjectMetadataItems(device, eventId, &ohfi) != PTP_RC_OK) { if(VitaMTP_SendObjectMetadataItems(m_device, eventId, &ohfi) != PTP_RC_OK) {
qWarning("Cannot get OHFI for retreving metadata"); qWarning("Cannot get OHFI for retreving metadata");
return; return;
} }
@@ -341,76 +341,75 @@ void CmaEvent::vitaEventSendObjectMetadataItems(vita_event_t *event, int eventId
if(!m_db->getObjectMetadata(ohfi, metadata)) { if(!m_db->getObjectMetadata(ohfi, metadata)) {
qWarning("Cannot find OHFI %d in database", ohfi); qWarning("Cannot find OHFI %d in database", ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} }
metadata.next_metadata = NULL; metadata.next_metadata = NULL;
qDebug("Sending metadata for OHFI %d (%s)", ohfi, metadata.path); qDebug("Sending metadata for OHFI %d (%s)", ohfi, metadata.path);
quint16 ret = VitaMTP_SendObjectMetadata(device, eventId, &metadata); quint16 ret = VitaMTP_SendObjectMetadata(m_device, eventId, &metadata);
if(ret != PTP_RC_OK) { if(ret != PTP_RC_OK) {
qWarning("Error sending metadata. Code: %04X", ret); qWarning("Error sending metadata. Code: %04X", ret);
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} }
void CmaEvent::vitaEventSendNPAccountInfo(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendNPAccountInfo(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
// AFAIK, Sony hasn't even implemented this in their CMA // AFAIK, Sony hasn't even implemented this in their CMA
qWarning("Event 0x%x unimplemented!", event->Code); qWarning("Event 0x%x unimplemented!", cma_event->Code);
} }
void CmaEvent::vitaEventUnimplementated(vita_event_t *event, int eventId) void CmaEvent::vitaEventUnimplementated(vita_event_t *cma_event, int eventId)
{ {
qWarning("Unknown event not handled, code: 0x%x, id: %d", event->Code, eventId); qWarning("Unknown event not handled, code: 0x%x, id: %d", cma_event->Code, eventId);
qWarning("Param1: 0x%08X, Param2: 0x%08X, Param3: 0x%08X", event->Param1, event->Param2, event->Param3); qWarning("Param1: 0x%08X, Param2: 0x%08X, Param3: 0x%08X", cma_event->Param1, cma_event->Param2, cma_event->Param3);
} }
void CmaEvent::vitaEventCancelTask(vita_event_t *event, int eventId) void CmaEvent::vitaEventCancelTask(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
quint32 eventIdToCancel = event->Param2; quint32 eventIdToCancel = cma_event->Param2;
qDebug("Cancelling event %d", eventIdToCancel); qDebug("Cancelling event %d", eventIdToCancel);
quint16 ret = VitaMTP_CancelTask(device, eventIdToCancel); quint16 ret = VitaMTP_CancelTask(m_device, eventIdToCancel);
// wait until the current event finishes so we can report the result to the device // wait until the current event finishes so we can report the result to the device
qDebug("Waiting for send event to finish"); qDebug("Waiting for send event to finish");
mutex.lock(); QMutexLocker locker(&mutex);
if(ret == PTP_RC_OK) { if(ret == PTP_RC_OK) {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
mutex.unlock();
} }
void CmaEvent::vitaEventSendNumOfObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendNumOfObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
QMutexLocker locker(&m_db->mutex); QMutexLocker locker(&m_db->mutex);
int ohfi = event->Param2; int ohfi = cma_event->Param2;
int items = m_db->childObjectCount(ohfi); int items = m_db->childObjectCount(ohfi);
if(VitaMTP_SendNumOfObject(device, eventId, items) != PTP_RC_OK) { if(VitaMTP_SendNumOfObject(m_device, eventId, items) != PTP_RC_OK) {
qWarning("Error occured receiving object count for OHFI parent %d", ohfi); qWarning("Error occured receiving object count for OHFI parent %d", ohfi);
} else { } else {
qDebug("Returned count of %d objects for OHFI parent %d", items, ohfi); qDebug("Returned count of %d objects for OHFI parent %d", items, ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} }
void CmaEvent::vitaEventSendObjectMetadata(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendObjectMetadata(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
browse_info_t browse; browse_info_t browse;
if(VitaMTP_GetBrowseInfo(device, eventId, &browse) != PTP_RC_OK) { if(VitaMTP_GetBrowseInfo(m_device, eventId, &browse) != PTP_RC_OK) {
qWarning("GetBrowseInfo failed"); qWarning("GetBrowseInfo failed");
return; return;
} }
@@ -421,19 +420,19 @@ void CmaEvent::vitaEventSendObjectMetadata(vita_event_t *event, int eventId)
int count = m_db->getObjectMetadatas(browse.ohfiParent, &meta, browse.index, browse.numObjects); // if meta is null, will return empty XML int count = m_db->getObjectMetadatas(browse.ohfiParent, &meta, browse.index, browse.numObjects); // if meta is null, will return empty XML
qDebug("Sending %i metadata filtered objects for OHFI %d", count, browse.ohfiParent); qDebug("Sending %i metadata filtered objects for OHFI %d", count, browse.ohfiParent);
if(VitaMTP_SendObjectMetadata(device, eventId, meta) != PTP_RC_OK) { // send all objects with OHFI parent if(VitaMTP_SendObjectMetadata(m_device, eventId, meta) != PTP_RC_OK) { // send all objects with OHFI parent
qWarning("Sending metadata for OHFI parent %d failed", browse.ohfiParent); qWarning("Sending metadata for OHFI parent %d failed", browse.ohfiParent);
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
m_db->freeMetadata(meta); m_db->freeMetadata(meta);
} }
void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
int ohfi = event->Param2; int ohfi = cma_event->Param2;
QMutexLocker locker(&m_db->mutex); QMutexLocker locker(&m_db->mutex);
@@ -442,12 +441,12 @@ void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId)
metadata_t *metadata = NULL; metadata_t *metadata = NULL;
if(!m_db->getObjectList(ohfi, &metadata)) { if(!m_db->getObjectList(ohfi, &metadata)) {
qWarning("Failed to find OHFI %d", ohfi); qWarning("Failed to find OHFI %d", ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} }
metadata_t *start = metadata; metadata_t *start = metadata;
quint32 parentHandle = event->Param3; quint32 parentHandle = cma_event->Param3;
bool send_folder = metadata->dataType & Folder; bool send_folder = metadata->dataType & Folder;
quint32 handle; quint32 handle;
@@ -461,7 +460,7 @@ void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId)
if(!m_file->open(QIODevice::ReadOnly)) { if(!m_file->open(QIODevice::ReadOnly)) {
qWarning() << "Failed to read" << m_file->fileName(); qWarning() << "Failed to read" << m_file->fileName();
delete m_file; delete m_file;
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Not_Exist_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
return; return;
} }
} }
@@ -481,11 +480,11 @@ void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId)
qDebug("OHFI %d with handle 0x%08X", metadata->ohfi, parentHandle); qDebug("OHFI %d with handle 0x%08X", metadata->ohfi, parentHandle);
VitaMTP_RegisterCancelEventId(eventId); VitaMTP_RegisterCancelEventId(eventId);
quint16 ret = VitaMTP_SendObject_Callback(device, &parentHandle, &handle, metadata, &CmaEvent::readCallback); quint16 ret = VitaMTP_SendObject_Callback(m_device, &parentHandle, &handle, metadata, &CmaEvent::readCallback);
if(ret != PTP_RC_OK) { if(ret != PTP_RC_OK) {
qWarning("Sending of %s failed. Code: %04X", metadata->name, ret); qWarning("Sending of %s failed. Code: %04X", metadata->name, ret);
if(ret == PTP_ERROR_CANCEL) { if(ret == PTP_ERROR_CANCEL) {
VitaMTP_ReportResult(device, eventId, PTP_RC_GeneralError); VitaMTP_ReportResult(m_device, eventId, PTP_RC_GeneralError);
} }
m_file->close(); m_file->close();
delete m_file; delete m_file;
@@ -510,17 +509,17 @@ void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId)
m_db->freeMetadata(start); m_db->freeMetadata(start);
VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, handle); VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, handle);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Data); // TODO: Send thumbnail VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Data); // TODO: Send thumbnail
} }
void CmaEvent::vitaEventSendHttpObjectFromURL(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendHttpObjectFromURL(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
char *url; char *url;
if(VitaMTP_GetUrl(device, eventId, &url) != PTP_RC_OK) { if(VitaMTP_GetUrl(m_device, eventId, &url) != PTP_RC_OK) {
qWarning("Failed to recieve URL"); qWarning("Failed to recieve URL");
return; return;
} }
@@ -558,15 +557,15 @@ void CmaEvent::vitaEventSendHttpObjectFromURL(vita_event_t *event, int eventId)
remote_size += 8; remote_size += 8;
qDebug("Sending %i bytes of data for HTTP request %s", remote_size, url); qDebug("Sending %i bytes of data for HTTP request %s", remote_size, url);
if(VitaMTP_SendData_Callback(device, eventId, PTP_OC_VITA_SendHttpObjectFromURL, remote_size, HTTPDownloader::readCallback) != PTP_RC_OK) { if(VitaMTP_SendData_Callback(m_device, eventId, PTP_OC_VITA_SendHttpObjectFromURL, remote_size, HTTPDownloader::readCallback) != PTP_RC_OK) {
qWarning("Failed to send HTTP object"); qWarning("Failed to send HTTP object");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} else { } else {
qWarning("No valid content-length in header, aborting"); qWarning("No valid content-length in header, aborting");
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Download); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Download);
} }
free(url); free(url);
@@ -581,22 +580,22 @@ void CmaEvent::vitaEventSendHttpObjectFromURL(vita_event_t *event, int eventId)
qDebug("Sending %i bytes of data for HTTP request %s", data.size(), url); qDebug("Sending %i bytes of data for HTTP request %s", data.size(), url);
if(VitaMTP_SendHttpObjectFromURL(device, eventId, data.data(), data.size()) != PTP_RC_OK) { if(VitaMTP_SendHttpObjectFromURL(m_device, eventId, data.data(), data.size()) != PTP_RC_OK) {
qWarning("Failed to send HTTP object"); qWarning("Failed to send HTTP object");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
free(url); free(url);
} }
void CmaEvent::vitaEventSendObjectStatus(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendObjectStatus(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
object_status_t objectstatus; object_status_t objectstatus;
if(VitaMTP_SendObjectStatus(device, eventId, &objectstatus) != PTP_RC_OK) { if(VitaMTP_SendObjectStatus(m_device, eventId, &objectstatus) != PTP_RC_OK) {
qWarning("Failed to get information for object status."); qWarning("Failed to get information for object status.");
return; return;
} }
@@ -608,35 +607,35 @@ void CmaEvent::vitaEventSendObjectStatus(vita_event_t *event, int eventId)
if(ohfi == 0) { // not in database, don't return metadata if(ohfi == 0) { // not in database, don't return metadata
qDebug("Object %s not in database (OHFI: %i). Sending OK response for non-existence", objectstatus.title, objectstatus.ohfiRoot); qDebug("Object %s not in database (OHFI: %i). Sending OK response for non-existence", objectstatus.title, objectstatus.ohfiRoot);
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} else { } else {
metadata_t metadata = metadata_t(); metadata_t metadata = metadata_t();
m_db->getObjectMetadata(ohfi, metadata); m_db->getObjectMetadata(ohfi, metadata);
metadata.next_metadata = NULL; metadata.next_metadata = NULL;
qDebug("Sending metadata for OHFI %d", ohfi); qDebug("Sending metadata for OHFI %d", ohfi);
if(VitaMTP_SendObjectMetadata(device, eventId, &metadata) != PTP_RC_OK) { if(VitaMTP_SendObjectMetadata(m_device, eventId, &metadata) != PTP_RC_OK) {
qWarning("Error sending metadata for %d", ohfi); qWarning("Error sending metadata for %d", ohfi);
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} }
free(objectstatus.title); free(objectstatus.title);
} }
void CmaEvent::vitaEventSendObjectThumb(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendObjectThumb(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
QMutexLocker locker(&m_db->mutex); QMutexLocker locker(&m_db->mutex);
int ohfi = event->Param2; int ohfi = cma_event->Param2;
metadata_t metadata; metadata_t metadata;
if(!m_db->getObjectMetadata(ohfi, metadata)) { if(!m_db->getObjectMetadata(ohfi, metadata)) {
qWarning("Cannot find OHFI %d in database.", ohfi); qWarning("Cannot find OHFI %d in database.", ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} }
@@ -645,7 +644,7 @@ void CmaEvent::vitaEventSendObjectThumb(vita_event_t *event, int eventId)
if(data.size() == 0) { if(data.size() == 0) {
qWarning() << "Cannot find/read thumbnail for" << fullpath; qWarning() << "Cannot find/read thumbnail for" << fullpath;
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Data); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Data);
return; return;
} }
@@ -655,10 +654,10 @@ void CmaEvent::vitaEventSendObjectThumb(vita_event_t *event, int eventId)
char *locale = strdup(setlocale(LC_ALL, NULL)); char *locale = strdup(setlocale(LC_ALL, NULL));
setlocale(LC_ALL, "C"); setlocale(LC_ALL, "C");
if(VitaMTP_SendObjectThumb(device, eventId, (metadata_t *)&g_thumbmeta, (uchar *)data.data(), data.size()) != PTP_RC_OK) { if(VitaMTP_SendObjectThumb(m_device, eventId, (metadata_t *)&g_thumbmeta, (uchar *)data.data(), data.size()) != PTP_RC_OK) {
qWarning("Error sending thumbnail"); qWarning("Error sending thumbnail");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
// restore locale // restore locale
@@ -666,18 +665,18 @@ void CmaEvent::vitaEventSendObjectThumb(vita_event_t *event, int eventId)
free(locale); free(locale);
} }
void CmaEvent::vitaEventDeleteObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventDeleteObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
QMutexLocker locker(&m_db->mutex); QMutexLocker locker(&m_db->mutex);
int ohfi = event->Param2; int ohfi = cma_event->Param2;
metadata_t metadata; metadata_t metadata;
if(!m_db->getObjectMetadata(ohfi, metadata)) { if(!m_db->getObjectMetadata(ohfi, metadata)) {
qWarning("OHFI %d not found", ohfi); qWarning("OHFI %d not found", ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} }
@@ -686,15 +685,15 @@ void CmaEvent::vitaEventDeleteObject(vita_event_t *event, int eventId)
removeRecursively(fullpath); removeRecursively(fullpath);
m_db->deleteEntry(ohfi); m_db->deleteEntry(ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
void CmaEvent::vitaEventGetSettingInfo(vita_event_t *event, int eventId) void CmaEvent::vitaEventGetSettingInfo(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
settings_info_t *settingsinfo; settings_info_t *settingsinfo;
if(VitaMTP_GetSettingInfo(device, eventId, &settingsinfo) != PTP_RC_OK) { if(VitaMTP_GetSettingInfo(m_device, eventId, &settingsinfo) != PTP_RC_OK) {
qWarning("Failed to get setting info from Vita."); qWarning("Failed to get setting info from Vita.");
return; return;
} }
@@ -711,15 +710,15 @@ void CmaEvent::vitaEventGetSettingInfo(vita_event_t *event, int eventId)
// free all the information // free all the information
VitaMTP_Data_Free_Settings(settingsinfo); VitaMTP_Data_Free_Settings(settingsinfo);
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
void CmaEvent::vitaEventSendHttpObjectPropFromURL(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendHttpObjectPropFromURL(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
char *url; char *url;
if(VitaMTP_GetUrl(device, eventId, &url) != PTP_RC_OK) { if(VitaMTP_GetUrl(m_device, eventId, &url) != PTP_RC_OK) {
qWarning("Failed to get URL"); qWarning("Failed to get URL");
return; return;
} }
@@ -730,7 +729,7 @@ void CmaEvent::vitaEventSendHttpObjectPropFromURL(vita_event_t *event, int event
if(!file.exists()) { if(!file.exists()) {
qWarning("The file %s is not accesible", url); qWarning("The file %s is not accesible", url);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Download); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Download);
free(url); free(url);
return; return;
} }
@@ -741,22 +740,22 @@ void CmaEvent::vitaEventSendHttpObjectPropFromURL(vita_event_t *event, int event
httpobjectprop.timestamp = timestamp.toUtf8().data(); httpobjectprop.timestamp = timestamp.toUtf8().data();
httpobjectprop.timestamp_len = timestamp.toUtf8().size(); httpobjectprop.timestamp_len = timestamp.toUtf8().size();
if(VitaMTP_SendHttpObjectPropFromURL(device, eventId, &httpobjectprop) != PTP_RC_OK) { if(VitaMTP_SendHttpObjectPropFromURL(m_device, eventId, &httpobjectprop) != PTP_RC_OK) {
qWarning("Failed to send object properties"); qWarning("Failed to send object properties");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
free(url); free(url);
} }
void CmaEvent::vitaEventSendPartOfObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendPartOfObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
send_part_init_t part_init; send_part_init_t part_init;
if(VitaMTP_SendPartOfObjectInit(device, eventId, &part_init) != PTP_RC_OK) { if(VitaMTP_SendPartOfObjectInit(m_device, eventId, &part_init) != PTP_RC_OK) {
qWarning("Cannot get information on object to send"); qWarning("Cannot get information on object to send");
return; return;
} }
@@ -767,7 +766,7 @@ void CmaEvent::vitaEventSendPartOfObject(vita_event_t *event, int eventId)
if(fullpath.isNull()) { if(fullpath.isNull()) {
qWarning("Cannot find object for OHFI %d", part_init.ohfi); qWarning("Cannot find object for OHFI %d", part_init.ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Context); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Context);
return; return;
} }
@@ -775,7 +774,7 @@ void CmaEvent::vitaEventSendPartOfObject(vita_event_t *event, int eventId)
if(!file.open(QIODevice::ReadOnly)) { if(!file.open(QIODevice::ReadOnly)) {
qWarning() << "Cannot read" << fullpath; qWarning() << "Cannot read" << fullpath;
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Not_Exist_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
return; return;
} else { } else {
file.seek(part_init.offset); file.seek(part_init.offset);
@@ -784,21 +783,21 @@ void CmaEvent::vitaEventSendPartOfObject(vita_event_t *event, int eventId)
fullpath, QString::number(part_init.offset), QString::number(part_init.size) fullpath, QString::number(part_init.offset), QString::number(part_init.size)
); );
if(VitaMTP_SendPartOfObject(device, eventId, (unsigned char *)data.data(), data.size()) != PTP_RC_OK) { if(VitaMTP_SendPartOfObject(m_device, eventId, (unsigned char *)data.data(), data.size()) != PTP_RC_OK) {
qWarning("Failed to send part of object OHFI %d", part_init.ohfi); qWarning("Failed to send part of object OHFI %d", part_init.ohfi);
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} }
} }
void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventOperateObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
operate_object_t operateobject; operate_object_t operateobject;
if(VitaMTP_OperateObject(device, eventId, &operateobject) != PTP_RC_OK) { if(VitaMTP_OperateObject(m_device, eventId, &operateobject) != PTP_RC_OK) {
qWarning("Cannot get information on object to operate"); qWarning("Cannot get information on object to operate");
return; return;
} }
@@ -809,7 +808,7 @@ void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId)
// end for renaming only // end for renaming only
if(fullpath.isNull()) { if(fullpath.isNull()) {
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Not_Exist_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
return; return;
} }
@@ -820,11 +819,11 @@ void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId)
QDir dir(fullpath); QDir dir(fullpath);
if(!dir.mkdir(operateobject.title)) { if(!dir.mkdir(operateobject.title)) {
qWarning("Unable to create temporary folder: %s", operateobject.title); qWarning("Unable to create temporary folder: %s", operateobject.title);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
} else { } else {
int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi); int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi);
qDebug("Created folder %s with OHFI %d", operateobject.title, new_ohfi); qDebug("Created folder %s with OHFI %d", operateobject.title, new_ohfi);
VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, new_ohfi); VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, new_ohfi);
} }
break; break;
} }
@@ -834,11 +833,11 @@ void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId)
QFile file(fullpath + QDir::separator() + operateobject.title); QFile file(fullpath + QDir::separator() + operateobject.title);
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) { if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
qWarning("Unable to create temporary file: %s", operateobject.title); qWarning("Unable to create temporary file: %s", operateobject.title);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
} else { } else {
int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi); int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi);
//qDebug("Created file %s with OHFI %d under parent %s", newobj->metadata.path, new_ohfi, root->metadata.path); //qDebug("Created file %s with OHFI %d under parent %s", newobj->metadata.path, new_ohfi, root->metadata.path);
VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, new_ohfi); VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, new_ohfi);
} }
break; break;
} }
@@ -851,32 +850,32 @@ void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId)
// rename in filesystem // rename in filesystem
if(!QFile(fullpath).rename(newpath)) { if(!QFile(fullpath).rename(newpath)) {
qWarning("Unable to rename %s to %s", fullpath.toLocal8Bit().constData(), operateobject.title); qWarning("Unable to rename %s to %s", fullpath.toLocal8Bit().constData(), operateobject.title);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
break; break;
} }
qDebug("Renamed OHFI %d from %s to %s", operateobject.ohfi, fullpath.toLocal8Bit().constData(), newpath.toLocal8Bit().constData()); qDebug("Renamed OHFI %d from %s to %s", operateobject.ohfi, fullpath.toLocal8Bit().constData(), newpath.toLocal8Bit().constData());
VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, operateobject.ohfi); VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, operateobject.ohfi);
break; break;
} }
default: default:
qWarning("Operate command %d: Not implemented", operateobject.cmd); qWarning("Operate command %d: Not implemented", operateobject.cmd);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
break; break;
} }
free(operateobject.title); free(operateobject.title);
} }
void CmaEvent::vitaEventGetPartOfObject(vita_event_t *event, int eventId) void CmaEvent::vitaEventGetPartOfObject(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
unsigned char *data; unsigned char *data;
send_part_init_t part_init; send_part_init_t part_init;
if(VitaMTP_GetPartOfObject(device, eventId, &part_init, &data) != PTP_RC_OK) { if(VitaMTP_GetPartOfObject(m_device, eventId, &part_init, &data) != PTP_RC_OK) {
qWarning("Cannot get object from device"); qWarning("Cannot get object from device");
return; return;
} }
@@ -886,7 +885,7 @@ void CmaEvent::vitaEventGetPartOfObject(vita_event_t *event, int eventId)
if(fullpath.isNull()) { if(fullpath.isNull()) {
qWarning("Cannot find OHFI %d", part_init.ohfi); qWarning("Cannot find OHFI %d", part_init.ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
free(data); free(data);
return; return;
} }
@@ -898,7 +897,7 @@ void CmaEvent::vitaEventGetPartOfObject(vita_event_t *event, int eventId)
QFile file(fullpath); QFile file(fullpath);
if(!file.open(QIODevice::ReadWrite)) { if(!file.open(QIODevice::ReadWrite)) {
qWarning() << "Cannot write to file" << fullpath; qWarning() << "Cannot write to file" << fullpath;
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Permission); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
} else { } else {
file.seek(part_init.offset); file.seek(part_init.offset);
file.write((const char *)data, part_init.size); file.write((const char *)data, part_init.size);
@@ -908,24 +907,24 @@ void CmaEvent::vitaEventGetPartOfObject(vita_event_t *event, int eventId)
QString::number(part_init.size), fullpath, QString::number(part_init.offset) QString::number(part_init.size), fullpath, QString::number(part_init.offset)
); );
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
free(data); free(data);
} }
void CmaEvent::vitaEventSendStorageSize(vita_event_t *event, int eventId) void CmaEvent::vitaEventSendStorageSize(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
QMutexLocker locker(&m_db->mutex); QMutexLocker locker(&m_db->mutex);
int ohfi = event->Param2; int ohfi = cma_event->Param2;
QString fullpath = m_db->getAbsolutePath(ohfi); QString fullpath = m_db->getAbsolutePath(ohfi);
if(fullpath.isNull()) { if(fullpath.isNull()) {
qWarning("Error: Cannot find OHFI %d", ohfi); qWarning("Error: Cannot find OHFI %d", ohfi);
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
return; return;
} else { } else {
QFile file(fullpath); QFile file(fullpath);
@@ -936,7 +935,7 @@ void CmaEvent::vitaEventSendStorageSize(vita_event_t *event, int eventId)
if(!QDir(QDir::root()).mkpath(QDir(fullpath).absolutePath())) { if(!QDir(QDir::root()).mkpath(QDir(fullpath).absolutePath())) {
qWarning("Create directory failed"); qWarning("Create directory failed");
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Permission); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
return; return;
} }
} }
@@ -947,27 +946,27 @@ void CmaEvent::vitaEventSendStorageSize(vita_event_t *event, int eventId)
if(!getDiskSpace(fullpath, &free, &total)) { if(!getDiskSpace(fullpath, &free, &total)) {
qWarning("Cannot get disk space"); qWarning("Cannot get disk space");
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Permission); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
return; return;
} }
qDebug("Storage stats for drive containing OHFI %d, free: %llu, total: %llu", ohfi, free, total); qDebug("Storage stats for drive containing OHFI %d, free: %llu, total: %llu", ohfi, free, total);
if(VitaMTP_SendStorageSize(device, eventId, total, free) != PTP_RC_OK) { if(VitaMTP_SendStorageSize(m_device, eventId, total, free) != PTP_RC_OK) {
qWarning("Send storage size failed"); qWarning("Send storage size failed");
} else { } else {
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
} }
void CmaEvent::vitaEventCheckExistance(vita_event_t *event, int eventId) void CmaEvent::vitaEventCheckExistance(vita_event_t *cma_event, int eventId)
{ {
qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
int handle = event->Param2; int handle = cma_event->Param2;
existance_object_t existance; existance_object_t existance;
if(VitaMTP_CheckExistance(device, handle, &existance) != PTP_RC_OK) { if(VitaMTP_CheckExistance(m_device, handle, &existance) != PTP_RC_OK) {
qWarning("Cannot read information on object to be sent"); qWarning("Cannot read information on object to be sent");
return; return;
} }
@@ -977,12 +976,12 @@ void CmaEvent::vitaEventCheckExistance(vita_event_t *event, int eventId)
int ohfi = m_db->getPathId(existance.name, 0); int ohfi = m_db->getPathId(existance.name, 0);
if(ohfi == 0) { if(ohfi == 0) {
VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Different_Object); VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Different_Object);
} else { } else {
VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_VITA_Same_Object, ohfi); VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_VITA_Same_Object, ohfi);
} }
VitaMTP_ReportResult(device, eventId, PTP_RC_OK); VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
} }
int CmaEvent::readCallback(unsigned char *data, unsigned long wantlen, unsigned long *gotlen) int CmaEvent::readCallback(unsigned char *data, unsigned long wantlen, unsigned long *gotlen)

6
src/cmaevent.h
View File

@@ -64,10 +64,10 @@ private:
void processEvent(); void processEvent();
bool isActive(); bool isActive();
void setDevice(vita_device_t *device); void setDevice(vita_device_t *m_device);
vita_device_t *device; vita_device_t *m_device;
vita_event_t t_event; vita_event_t m_event;
Database *m_db; Database *m_db;

28
src/cmaobject.cpp
View File

@@ -109,7 +109,7 @@ void CMAObject::loadSfoMetadata(const QString &path)
} }
} }
void CMAObject::initObject(const QFileInfo &file, int file_type) void CMAObject::initObject(const QFileInfo &file, int obj_file_type)
{ {
metadata.name = strdup(file.fileName().toUtf8().data()); metadata.name = strdup(file.fileName().toUtf8().data());
metadata.ohfiParent = parent->metadata.ohfi; metadata.ohfiParent = parent->metadata.ohfi;
@@ -128,18 +128,18 @@ void CMAObject::initObject(const QFileInfo &file, int file_type)
loadSfoMetadata(file.absoluteFilePath()); loadSfoMetadata(file.absoluteFilePath());
} else if(MASK_SET(metadata.dataType, Music | File)) { } else if(MASK_SET(metadata.dataType, Music | File)) {
if(file_type < 0) { if(obj_file_type < 0) {
qWarning("Invalid file type for music: %i, setting it to zero", file_type); qWarning("Invalid file type for music: %i, setting it to zero", obj_file_type);
file_type = 0; obj_file_type = 0;
} }
metadata.data.music.fileName = strdup(metadata.name); metadata.data.music.fileName = strdup(metadata.name);
metadata.data.music.fileFormatType = audio_list[file_type].file_format; metadata.data.music.fileFormatType = audio_list[obj_file_type].file_format;
metadata.data.music.statusType = 1; metadata.data.music.statusType = 1;
metadata.data.music.numTracks = 1; metadata.data.music.numTracks = 1;
metadata.data.music.tracks = new media_track(); metadata.data.music.tracks = new media_track();
metadata.data.music.tracks->type = VITA_TRACK_TYPE_AUDIO; metadata.data.music.tracks->type = VITA_TRACK_TYPE_AUDIO;
metadata.data.music.tracks->data.track_photo.codecType = audio_list[file_type].file_codec; metadata.data.music.tracks->data.track_photo.codecType = audio_list[obj_file_type].file_codec;
Database::loadMusicMetadata(file.absoluteFilePath(), metadata); Database::loadMusicMetadata(file.absoluteFilePath(), metadata);
} else if(MASK_SET(metadata.dataType, Video | File)) { } else if(MASK_SET(metadata.dataType, Video | File)) {
metadata.data.video.fileName = strdup(metadata.name); metadata.data.video.fileName = strdup(metadata.name);
@@ -153,23 +153,23 @@ void CMAObject::initObject(const QFileInfo &file, int file_type)
Database::loadVideoMetadata(file.absoluteFilePath(), metadata); Database::loadVideoMetadata(file.absoluteFilePath(), metadata);
} else if(MASK_SET(metadata.dataType, Photo | File)) { } else if(MASK_SET(metadata.dataType, Photo | File)) {
if(file_type < 0) { if(obj_file_type < 0) {
qWarning("Invalid file type for photos: %i, setting it to zero", file_type); qWarning("Invalid file type for photos: %i, setting it to zero", obj_file_type);
file_type = 0; obj_file_type = 0;
} }
metadata.data.photo.fileName = strdup(metadata.name); metadata.data.photo.fileName = strdup(metadata.name);
metadata.data.photo.fileFormatType = photo_list[file_type].file_format; metadata.data.photo.fileFormatType = photo_list[obj_file_type].file_format;
metadata.data.photo.statusType = 1; metadata.data.photo.statusType = 1;
metadata.data.photo.dateTimeOriginal = file.created().toUTC().toTime_t(); metadata.data.photo.dateTimeOriginal = file.created().toUTC().toTime_t();
metadata.data.photo.numTracks = 1; metadata.data.photo.numTracks = 1;
metadata.data.photo.tracks = new media_track(); metadata.data.photo.tracks = new media_track();
metadata.data.photo.tracks->type = VITA_TRACK_TYPE_PHOTO; metadata.data.photo.tracks->type = VITA_TRACK_TYPE_PHOTO;
metadata.data.photo.tracks->data.track_photo.codecType = photo_list[file_type].file_codec; metadata.data.photo.tracks->data.track_photo.codecType = photo_list[obj_file_type].file_codec;
Database::loadPhotoMetadata(file.absoluteFilePath(), metadata); Database::loadPhotoMetadata(file.absoluteFilePath(), metadata);
} }
path = file.absoluteFilePath(); m_path = file.absoluteFilePath();
if(parent->metadata.path == NULL) { if(parent->metadata.path == NULL) {
metadata.path = strdup(metadata.name); metadata.path = strdup(metadata.name);
@@ -201,7 +201,7 @@ void CMAObject::rename(const QString &newname)
metadata.path = strdup(metadata_path.join("/").toUtf8().data()); metadata.path = strdup(metadata_path.join("/").toUtf8().data());
} }
path = QFileInfo(path).absoluteDir().path() + "/" + newname; m_path = QFileInfo(m_path).absoluteDir().path() + "/" + newname;
} }
void CMAObject::refreshPath() void CMAObject::refreshPath()
@@ -210,7 +210,7 @@ void CMAObject::refreshPath()
free(metadata.path); free(metadata.path);
QString newpath(QString(parent->metadata.path) + "/" + metadata.name); QString newpath(QString(parent->metadata.path) + "/" + metadata.name);
metadata.path = strdup(newpath.toUtf8().data()); metadata.path = strdup(newpath.toUtf8().data());
path = parent->path + "/" + metadata.name; m_path = parent->m_path + "/" + metadata.name;
} }
} }

2
src/cmaobject.h
View File

@@ -51,7 +51,7 @@ public:
ohfi_count = OHFI_OFFSET; ohfi_count = OHFI_OFFSET;
} }
QString path; QString m_path;
CMAObject *parent; CMAObject *parent;
metadata_t metadata; metadata_t metadata;

22
src/cmarootobject.cpp
View File

@@ -36,7 +36,7 @@ void CMARootObject::initObject(const QString &path)
switch(root_ohfi) { switch(root_ohfi) {
case VITA_OHFI_MUSIC: case VITA_OHFI_MUSIC:
metadata.dataType = Music; metadata.dataType = Music;
this->path = path; m_path = path;
num_filters = 5; num_filters = 5;
filters = new metadata_t[5]; filters = new metadata_t[5];
createFilter(&filters[0], "Artists", VITA_DIR_TYPE_MASK_MUSIC | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ARTISTS); createFilter(&filters[0], "Artists", VITA_DIR_TYPE_MASK_MUSIC | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ARTISTS);
@@ -48,7 +48,7 @@ void CMARootObject::initObject(const QString &path)
case VITA_OHFI_PHOTO: case VITA_OHFI_PHOTO:
metadata.dataType = Photo; metadata.dataType = Photo;
this->path = path; m_path = path;
num_filters = 3; num_filters = 3;
filters = new metadata_t[3]; filters = new metadata_t[3];
createFilter(&filters[0], "All", VITA_DIR_TYPE_MASK_PHOTO | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ALL); createFilter(&filters[0], "All", VITA_DIR_TYPE_MASK_PHOTO | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ALL);
@@ -58,7 +58,7 @@ void CMARootObject::initObject(const QString &path)
case VITA_OHFI_VIDEO: case VITA_OHFI_VIDEO:
metadata.dataType = Video; metadata.dataType = Video;
this->path = path; m_path = path;
num_filters = 2; num_filters = 2;
filters = new metadata_t[2]; filters = new metadata_t[2];
createFilter(&filters[0], "All", VITA_DIR_TYPE_MASK_VIDEO | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ALL); createFilter(&filters[0], "All", VITA_DIR_TYPE_MASK_VIDEO | VITA_DIR_TYPE_MASK_ROOT | VITA_DIR_TYPE_MASK_ALL);
@@ -67,48 +67,48 @@ void CMARootObject::initObject(const QString &path)
case VITA_OHFI_VITAAPP: case VITA_OHFI_VITAAPP:
metadata.dataType = App; metadata.dataType = App;
this->path = QDir(QDir(path).absoluteFilePath("APP")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("APP")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_PSPAPP: case VITA_OHFI_PSPAPP:
metadata.dataType = App; metadata.dataType = App;
this->path = QDir(QDir(path).absoluteFilePath("PGAME")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("PGAME")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_PSPSAVE: case VITA_OHFI_PSPSAVE:
metadata.dataType = SaveData; metadata.dataType = SaveData;
this->path = QDir(QDir(path).absoluteFilePath("PSAVEDATA")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("PSAVEDATA")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_PSXAPP: case VITA_OHFI_PSXAPP:
metadata.dataType = App; metadata.dataType = App;
this->path = QDir(QDir(path).absoluteFilePath("PSGAME")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("PSGAME")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_PSMAPP: case VITA_OHFI_PSMAPP:
metadata.dataType = App; metadata.dataType = App;
this->path = QDir(QDir(path).absoluteFilePath("PSM")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("PSM")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_BACKUP: case VITA_OHFI_BACKUP:
metadata.dataType = App; metadata.dataType = App;
this->path = QDir(QDir(path).absoluteFilePath("SYSTEM")).absoluteFilePath(uuid); m_path = QDir(QDir(path).absoluteFilePath("SYSTEM")).absoluteFilePath(uuid);
num_filters = 0; num_filters = 0;
break; break;
case VITA_OHFI_PACKAGE: case VITA_OHFI_PACKAGE:
metadata.dataType = Package; metadata.dataType = Package;
this->path = path; m_path = path;
num_filters = 0; num_filters = 0;
} }
// create the backup directories // create the backup directories
QDir dir(this->path); QDir dir(m_path);
dir.mkpath(dir.absolutePath()); dir.mkpath(dir.absolutePath());
} }

2
src/cmautils.cpp
View File

@@ -89,7 +89,7 @@ bool removeRecursively(const QString &path)
} }
} }
QByteArray findFolderAlbumArt(const QString path, metadata_t *metadata) static QByteArray findFolderAlbumArt(const QString path, metadata_t *metadata)
{ {
QByteArray data; QByteArray data;
QDir folder(path); QDir folder(path);

4
src/database.cpp
View File

@@ -45,8 +45,8 @@ const file_type video_list[] = {
{"mp4", FILE_FORMAT_MP4, 0} {"mp4", FILE_FORMAT_MP4, 0}
}; };
Database::Database(QObject *parent) : Database::Database(QObject *obj_parent) :
QObject(parent), QObject(obj_parent),
mutex(QMutex::Recursive) mutex(QMutex::Recursive)
{ {
} }

5
src/dds.cpp
View File

@@ -947,10 +947,7 @@ static bool LoadCubeMap( QDataStream & s, const DDSHeader & header, QImage & img
return true; return true;
} }
static bool canReadDDS(QIODevice *device)
bool canReadDDS(QIODevice *device)
{ {
if (!device) { if (!device) {
qWarning("DDSHandler::canRead() called with no device"); qWarning("DDSHandler::canRead() called with no device");

16
src/forms/backupitem.cpp
View File

@@ -37,8 +37,8 @@ const QString BackupItem::infoTemplate = "<html><head/><body>"
"<p><span style=\" font-size:10pt;\">&nbsp;%1</span></p>" "<p><span style=\" font-size:10pt;\">&nbsp;%1</span></p>"
"</body></html>"; "</body></html>";
BackupItem::BackupItem(QWidget *parent) : BackupItem::BackupItem(QWidget *obj_parent) :
QWidget(parent), QWidget(obj_parent),
ui(new Ui::BackupItem) ui(new Ui::BackupItem)
{ {
ui->setupUi(this); ui->setupUi(this);
@@ -54,7 +54,7 @@ BackupItem::~BackupItem()
void BackupItem::openDirectory() void BackupItem::openDirectory()
{ {
QDesktopServices::openUrl(QUrl("file:///" + path)); QDesktopServices::openUrl(QUrl("file:///" + m_path));
} }
void BackupItem::removeEntry() void BackupItem::removeEntry()
@@ -69,13 +69,13 @@ const QPixmap *BackupItem::getIconPixmap()
void BackupItem::setDirectory(const QString &path) void BackupItem::setDirectory(const QString &path)
{ {
this->path = path; m_path = path;
} }
void BackupItem::setItemInfo(const QString &name, const QString &size, const QString &extra) void BackupItem::setItemInfo(const QString &name, const QString &item_size, const QString &extra)
{ {
ui->gameLabel->setText(gameTemplate.arg(name)); ui->gameLabel->setText(gameTemplate.arg(name));
ui->sizeLabel->setText(sizeTemplate.arg(size)); ui->sizeLabel->setText(sizeTemplate.arg(item_size));
ui->infoLabel->setText(infoTemplate.arg(extra)); ui->infoLabel->setText(infoTemplate.arg(extra));
} }
@@ -84,9 +84,9 @@ int BackupItem::getIconWidth()
return ui->itemPicture->width(); return ui->itemPicture->width();
} }
void BackupItem::setItemIcon(const QString &path, int width, bool try_dds) void BackupItem::setItemIcon(const QString &path, int item_width, bool try_dds)
{ {
ui->itemPicture->setMinimumWidth(width); ui->itemPicture->setMinimumWidth(item_width);
QPixmap pixmap(path); QPixmap pixmap(path);
if((pixmap.width() <= 0 || pixmap.height() <= 0) && try_dds) { if((pixmap.width() <= 0 || pixmap.height() <= 0) && try_dds) {
QImage image; QImage image;

6
src/forms/backupitem.h
View File

@@ -35,8 +35,8 @@ public:
~BackupItem(); ~BackupItem();
void setItemInfo(const QString &name, const QString &size, const QString &extra); void setItemInfo(const QString &name, const QString &size, const QString &extra);
void setItemIcon(const QString &path, int width = 48, bool try_dds = false); void setItemIcon(const QString &m_path, int width = 48, bool try_dds = false);
void setDirectory(const QString &path); void setDirectory(const QString &m_path);
const QPixmap *getIconPixmap(); const QPixmap *getIconPixmap();
int getIconWidth(); int getIconWidth();
@@ -46,7 +46,7 @@ public:
QString title; QString title;
private: private:
QString path; QString m_path;
Ui::BackupItem *ui; Ui::BackupItem *ui;
static const QString gameTemplate; static const QString gameTemplate;
static const QString sizeTemplate; static const QString sizeTemplate;

12
src/forms/backupmanagerform.cpp
View File

@@ -32,8 +32,8 @@
#include <vitamtp.h> #include <vitamtp.h>
BackupManagerForm::BackupManagerForm(Database *db, QWidget *parent) : BackupManagerForm::BackupManagerForm(Database *db, QWidget *obj_parent) :
QDialog(parent), m_db(db), QDialog(obj_parent), m_db(db),
ui(new Ui::BackupManagerForm) ui(new Ui::BackupManagerForm)
{ {
ui->setupUi(this); ui->setupUi(this);
@@ -83,9 +83,9 @@ void BackupManagerForm::removeEntry(BackupItem *item)
} }
} }
void BackupManagerForm::setBackupUsage(qint64 size) void BackupManagerForm::setBackupUsage(qint64 usage_size)
{ {
ui->usageLabel->setText(tr("Backup disk usage: %1").arg(readable_size(size, true))); ui->usageLabel->setText(tr("Backup disk usage: %1").arg(readable_size(usage_size, true)));
} }
void BackupManagerForm::loadBackupListing(int index) void BackupManagerForm::loadBackupListing(int index)
@@ -191,7 +191,7 @@ void BackupManagerForm::loadBackupListing(int index)
// show better size info for multi GiB backups // show better size info for multi GiB backups
bool use_gb = ohfi == VITA_OHFI_BACKUP && meta->size > 1024*1024*1024; bool use_gb = ohfi == VITA_OHFI_BACKUP && meta->size > 1024*1024*1024;
QString size = readable_size(meta->size, use_gb); QString read_size = readable_size(meta->size, use_gb);
QString info; QString info;
@@ -211,7 +211,7 @@ void BackupManagerForm::loadBackupListing(int index)
} }
} }
item->setItemInfo(game_name, size, info); item->setItemInfo(game_name, read_size, info);
item->setItemIcon(QDir(parent_path).absoluteFilePath(sys_dir ? "icon0.png" : "ICON0.PNG"), img_width, ohfi == VITA_OHFI_PSMAPP); item->setItemIcon(QDir(parent_path).absoluteFilePath(sys_dir ? "icon0.png" : "ICON0.PNG"), img_width, ohfi == VITA_OHFI_PSMAPP);
item->setDirectory(path + QDir::separator() + meta->name); item->setDirectory(path + QDir::separator() + meta->name);
item->resize(646, 68); item->resize(646, 68);

4
src/forms/configwidget.cpp
View File

@@ -35,8 +35,8 @@ extern "C" {
#define writableLocation storageLocation #define writableLocation storageLocation
#endif #endif
ConfigWidget::ConfigWidget(QWidget *parent) : ConfigWidget::ConfigWidget(QWidget *obj_parent) :
QDialog(parent), QDialog(obj_parent),
ui(new Ui::ConfigWidget) ui(new Ui::ConfigWidget)
{ {
ui->setupUi(this); ui->setupUi(this);

8
src/forms/confirmdialog.cpp
View File

@@ -25,8 +25,8 @@ const QString ConfirmDialog::messageTemplate = "<html><head/><body>"
"<p><span style=\"font-size:12pt; font-weight:600;\">%2</span></p>" "<p><span style=\"font-size:12pt; font-weight:600;\">%2</span></p>"
"</body></html>"; "</body></html>";
ConfirmDialog::ConfirmDialog(QWidget *parent) : ConfirmDialog::ConfirmDialog(QWidget *obj_parent) :
QDialog(parent), QDialog(obj_parent),
ui(new Ui::ConfirmDialog) ui(new Ui::ConfirmDialog)
{ {
ui->setupUi(this); ui->setupUi(this);
@@ -38,10 +38,10 @@ void ConfirmDialog::setMessageText(const QString message, const QString game_tit
ui->confirmText->setText(messageTemplate.arg(message, game_title)); ui->confirmText->setText(messageTemplate.arg(message, game_title));
} }
void ConfirmDialog::setMessagePixmap(const QPixmap &pixmap, int width) void ConfirmDialog::setMessagePixmap(const QPixmap &pixmap, int dialog_width)
{ {
ui->itemPicture->setPixmap(pixmap); ui->itemPicture->setPixmap(pixmap);
ui->itemPicture->setMinimumWidth(width); ui->itemPicture->setMinimumWidth(dialog_width);
} }
ConfirmDialog::~ConfirmDialog() ConfirmDialog::~ConfirmDialog()

4
src/forms/pinform.cpp
View File

@@ -28,8 +28,8 @@ const QString PinForm::pinFormat =
"<p><span style=\"font-size:24pt; font-weight:600;\">%1</span></p>" "<p><span style=\"font-size:24pt; font-weight:600;\">%1</span></p>"
"</body></html>"; "</body></html>";
PinForm::PinForm(QWidget *parent) : PinForm::PinForm(QWidget *obj_parent) :
QWidget(parent), QWidget(obj_parent),
ui(new Ui::PinForm) ui(new Ui::PinForm)
{ {
ui->setupUi(this); ui->setupUi(this);

4
src/forms/progressform.cpp
View File

@@ -23,8 +23,8 @@
#include <QDesktopWidget> #include <QDesktopWidget>
#include <QMessageBox> #include <QMessageBox>
ProgressForm::ProgressForm(QWidget *parent) : ProgressForm::ProgressForm(QWidget *obj_parent) :
QWidget(parent), QWidget(obj_parent),
ui(new Ui::ProgressForm) ui(new Ui::ProgressForm)
{ {
ui->setupUi(this); ui->setupUi(this);

4
src/gui/clientmanager.cpp
View File

@@ -26,8 +26,8 @@
#include <vitamtp.h> #include <vitamtp.h>
ClientManager::ClientManager(Database *db, QObject *parent) : ClientManager::ClientManager(Database *db, QObject *obj_parent) :
QObject(parent), m_db(db) QObject(obj_parent), m_db(db)
{ {
} }

8
src/gui/filterlineedit.cpp
View File

@@ -22,8 +22,8 @@
#include <QIcon> #include <QIcon>
#include <QStyle> #include <QStyle>
FilterLineEdit::FilterLineEdit(QWidget *parent) : FilterLineEdit::FilterLineEdit(QWidget *obj_parent) :
QLineEdit(parent) QLineEdit(obj_parent)
{ {
int frame_width = frameWidth(); int frame_width = frameWidth();
clearButton = new QToolButton(this); clearButton = new QToolButton(this);
@@ -45,9 +45,9 @@ FilterLineEdit::FilterLineEdit(QWidget *parent) :
qMax(min_size_hint.height(), clearButton->sizeHint().height() + frame_width)); qMax(min_size_hint.height(), clearButton->sizeHint().height() + frame_width));
} }
void FilterLineEdit::updateCloseButton(const QString& text) void FilterLineEdit::updateCloseButton(const QString& filter_text)
{ {
if(text.isEmpty() || text == tr("Filter")) { if(filter_text.isEmpty() || filter_text == tr("Filter")) {
clearButton->setVisible(false); clearButton->setVisible(false);
} else { } else {
clearButton->setVisible(true); clearButton->setVisible(true);

4
src/gui/main.cpp
View File

@@ -34,11 +34,11 @@
#include "mainwidget.h" #include "mainwidget.h"
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
void noMessageOutput(QtMsgType type, const QMessageLogContext &, const QString & str) static void noMessageOutput(QtMsgType type, const QMessageLogContext &, const QString & str)
{ {
const char * msg = str.toStdString().c_str(); const char * msg = str.toStdString().c_str();
#else #else
void noMessageOutput(QtMsgType type, const char *msg) static void noMessageOutput(QtMsgType type, const char *msg)
{ {
#endif #endif
Q_UNUSED(type); Q_UNUSED(type);

12
src/gui/mainwidget.cpp
View File

@@ -45,8 +45,8 @@ const QStringList MainWidget::path_list = QStringList() << "photoPath" << "music
bool sleptOnce = false; bool sleptOnce = false;
#ifdef Q_OS_LINUX #ifdef Q_OS_LINUX
MainWidget::MainWidget(QWidget *parent) : MainWidget::MainWidget(QWidget *obj_parent) :
QWidget(parent), db(NULL), configForm(NULL), managerForm(NULL), backupForm(NULL), dbus_conn(QDBusConnection::sessionBus()) QWidget(obj_parent), db(NULL), configForm(NULL), managerForm(NULL), backupForm(NULL), dbus_conn(QDBusConnection::sessionBus())
{ {
new ClientManagerAdaptor(this); new ClientManagerAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus(); QDBusConnection dbus = QDBusConnection::sessionBus();
@@ -184,8 +184,8 @@ void MainWidget::showAboutDialog()
// hack to expand the messagebox minimum size // hack to expand the messagebox minimum size
QSpacerItem* horizontalSpacer = new QSpacerItem(300, 0, QSizePolicy::Minimum, QSizePolicy::Expanding); QSpacerItem* horizontalSpacer = new QSpacerItem(300, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
QGridLayout* layout = (QGridLayout*)about.layout(); QGridLayout* widget_layout = (QGridLayout*)about.layout();
layout->addItem(horizontalSpacer, layout->rowCount(), 0, 1, layout->columnCount()); widget_layout->addItem(horizontalSpacer, widget_layout->rowCount(), 0, 1, widget_layout->columnCount());
about.show(); about.show();
about.exec(); about.exec();
@@ -206,7 +206,7 @@ void MainWidget::refreshDatabase()
managerForm->refreshDatabase(); managerForm->refreshDatabase();
} }
TrayIndicator *MainWidget::createTrayObject(QWidget *parent) TrayIndicator *MainWidget::createTrayObject(QWidget *obj_parent)
{ {
TrayFunctionPointer create_tray = NULL; TrayFunctionPointer create_tray = NULL;
@@ -242,7 +242,7 @@ TrayIndicator *MainWidget::createTrayObject(QWidget *parent)
} }
#endif #endif
// else QSystemTrayIcon // else QSystemTrayIcon
return (create_tray != NULL) ? create_tray(parent) : createTrayIndicator(parent); return (create_tray != NULL) ? create_tray(obj_parent) : createTrayIndicator(obj_parent);
} }
void MainWidget::createTrayIcon() void MainWidget::createTrayIcon()

10
src/httpdownloader.cpp
View File

@@ -34,8 +34,8 @@ QByteArray HTTPDownloader::buffer;
bool HTTPDownloader::bufferReady = false; bool HTTPDownloader::bufferReady = false;
qint64 HTTPDownloader::downloadLeft = 0; qint64 HTTPDownloader::downloadLeft = 0;
HTTPDownloader::HTTPDownloader(const QString &url, QObject *parent) : HTTPDownloader::HTTPDownloader(const QString &url, QObject *obj_parent) :
QObject(parent), remote_url(url), firstRead(true) QObject(obj_parent), remote_url(url), firstRead(true)
{ {
lengthMutex.lock(); lengthMutex.lock();
} }
@@ -123,10 +123,10 @@ int HTTPDownloader::readCallback(unsigned char *data, unsigned long wantlen, uns
void HTTPDownloader::error(QNetworkReply::NetworkError errorCode) void HTTPDownloader::error(QNetworkReply::NetworkError errorCode)
{ {
Q_UNUSED(errorCode); Q_UNUSED(errorCode);
QString error = reply->errorString(); QString str_error = reply->errorString();
qWarning() << "Network error:" << error; qWarning() << "Network error:" << str_error;
emit messageSent(tr("Network error: %1").arg(error)); emit messageSent(tr("Network error: %1").arg(str_error));
lengthMutex.unlock(); lengthMutex.unlock();

4
src/indicator/kdenotifier.cpp
View File

@@ -19,7 +19,7 @@
#include "kdenotifier.h" #include "kdenotifier.h"
KDENotifier::KDENotifier(const QString &id, QObject *parent) : KDENotifier::KDENotifier(const QString &notifier_id, QObject *obj_parent) :
KStatusNotifierItem(id, parent) KStatusNotifierItem(notifier_id, obj_parent)
{ {
} }

4
src/indicator/kdenotifiertray.cpp
View File

@@ -24,8 +24,8 @@
#include <QMenu> #include <QMenu>
#endif #endif
KDENotifierTray::KDENotifierTray(QWidget *parent) KDENotifierTray::KDENotifierTray(QWidget *obj_parent)
: TrayIndicator(parent) : TrayIndicator(obj_parent)
{ {
} }

4
src/indicator/qtrayicon.cpp
View File

@@ -31,8 +31,8 @@ extern "C" {
#define signals public #define signals public
#endif #endif
QTrayIcon::QTrayIcon(QWidget *parent) QTrayIcon::QTrayIcon(QWidget *obj_parent)
: TrayIndicator(parent) : TrayIndicator(obj_parent)
{ {
#ifdef Q_OS_LINUX #ifdef Q_OS_LINUX
notify_init("qcma"); notify_init("qcma");

2
src/indicator/trayindicator.h
View File

@@ -44,7 +44,7 @@ public:
virtual void hide() = 0; virtual void hide() = 0;
protected: protected:
TrayIndicator(QWidget *parent = 0) : QWidget(parent) {} TrayIndicator(QWidget *obj_parent = 0) : QWidget(obj_parent) {}
signals: signals:
void openConfig(); void openConfig();

4
src/indicator/unityindicator.cpp
View File

@@ -47,8 +47,8 @@ void quitIndicator(GtkMenu *menu, gpointer data);
#define signals public #define signals public
UnityIndicator::UnityIndicator(QWidget *parent) : UnityIndicator::UnityIndicator(QWidget *obj_parent) :
TrayIndicator(parent) TrayIndicator(obj_parent)
{ {
notify_init("qcma"); notify_init("qcma");
} }

60
src/qlistdb.cpp
View File

@@ -28,8 +28,8 @@
#include <QThread> #include <QThread>
#include <QDebug> #include <QDebug>
QListDB::QListDB(QObject *parent) : QListDB::QListDB(QObject *obj_parent) :
Database(parent) Database(obj_parent)
{ {
QString uuid = QSettings().value("lastAccountId", "ffffffffffffffff").toString(); QString uuid = QSettings().value("lastAccountId", "ffffffffffffffff").toString();
CMARootObject::uuid = uuid; CMARootObject::uuid = uuid;
@@ -138,7 +138,7 @@ int QListDB::create()
root_list list; root_list list;
list << obj; list << obj;
emit directoryAdded(obj->path); emit directoryAdded(obj->m_path);
if(!skipCurrent) { if(!skipCurrent) {
dir_count = recursiveScanRootDirectory(list, obj, ohfi_array[i]); dir_count = recursiveScanRootDirectory(list, obj, ohfi_array[i]);
@@ -160,7 +160,7 @@ int QListDB::create()
CMAObject *QListDB::getParent(CMAObject *last_dir, const QString &current_path) CMAObject *QListDB::getParent(CMAObject *last_dir, const QString &current_path)
{ {
while(last_dir && current_path != last_dir->path) { while(last_dir && current_path != last_dir->m_path) {
last_dir = last_dir->parent; last_dir = last_dir->parent;
} }
@@ -169,10 +169,10 @@ CMAObject *QListDB::getParent(CMAObject *last_dir, const QString &current_path)
int QListDB::scanRootDirectory(root_list &list, int ohfi_type) int QListDB::scanRootDirectory(root_list &list, int ohfi_type)
{ {
int file_type = -1; int obj_file_type = -1;
int total_objects = 0; int total_objects = 0;
CMAObject *last_dir = list.first(); CMAObject *last_dir = list.first();
QDir dir(last_dir->path); QDir dir(last_dir->m_path);
dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot); dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
QDirIterator it(dir, QDirIterator::Subdirectories); QDirIterator it(dir, QDirIterator::Subdirectories);
@@ -186,14 +186,14 @@ int QListDB::scanRootDirectory(root_list &list, int ohfi_type)
QFileInfo info = it.fileInfo(); QFileInfo info = it.fileInfo();
if(info.isFile()) { if(info.isFile()) {
if((file_type = checkFileType(info.absoluteFilePath(), ohfi_type)) < 0) { if((obj_file_type = checkFileType(info.absoluteFilePath(), ohfi_type)) < 0) {
//qDebug("Excluding %s from database", info.absoluteFilePath().toStdString().c_str()); //qDebug("Excluding %s from database", info.absoluteFilePath().toStdString().c_str());
continue; continue;
} }
} }
CMAObject *obj = new CMAObject(getParent(last_dir, info.path())); CMAObject *obj = new CMAObject(getParent(last_dir, info.path()));
obj->initObject(info, file_type); obj->initObject(info, obj_file_type);
//qDebug("Added %s to database with OHFI %d", obj->metadata.name, obj->metadata.ohfi); //qDebug("Added %s to database with OHFI %d", obj->metadata.name, obj->metadata.ohfi);
list << obj; list << obj;
@@ -206,12 +206,12 @@ int QListDB::scanRootDirectory(root_list &list, int ohfi_type)
return total_objects; return total_objects;
} }
int QListDB::recursiveScanRootDirectory(root_list &list, CMAObject *parent, int ohfi_type) int QListDB::recursiveScanRootDirectory(root_list &list, CMAObject *obj_parent, int ohfi_type)
{ {
int file_type = -1; int obj_file_type = -1;
int total_objects = 0; int total_objects = 0;
QDir dir(parent->path); QDir dir(obj_parent->m_path);
dir.setSorting(QDir::Name | QDir::DirsFirst); dir.setSorting(QDir::Name | QDir::DirsFirst);
QFileInfoList qsl = dir.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot, QDir::Time); QFileInfoList qsl = dir.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot, QDir::Time);
@@ -221,16 +221,16 @@ int QListDB::recursiveScanRootDirectory(root_list &list, CMAObject *parent, int
return -1; return -1;
} }
if(info.isFile() && (file_type = checkFileType(info.absoluteFilePath(), ohfi_type)) < 0) { if(info.isFile() && (obj_file_type = checkFileType(info.absoluteFilePath(), ohfi_type)) < 0) {
//qDebug("Excluding %s from database", info.absoluteFilePath().toStdString().c_str());> //qDebug("Excluding %s from database", info.absoluteFilePath().toStdString().c_str());>
} else { } else {
CMAObject *obj = new CMAObject(parent); CMAObject *obj = new CMAObject(obj_parent);
obj->initObject(info, file_type); obj->initObject(info, obj_file_type);
emit fileAdded(obj->metadata.name); emit fileAdded(obj->metadata.name);
//qDebug("Added %s to database with OHFI %d", obj->metadata.name, obj->metadata.ohfi); //qDebug("Added %s to database with OHFI %d", obj->metadata.name, obj->metadata.ohfi);
list << obj; list << obj;
if(info.isDir()) { if(info.isDir()) {
emit directoryAdded(obj->path); emit directoryAdded(obj->m_path);
total_objects += recursiveScanRootDirectory(list, obj, ohfi_type); total_objects += recursiveScanRootDirectory(list, obj, ohfi_type);
} else { } else {
total_objects++; total_objects++;
@@ -319,7 +319,7 @@ CMAObject *QListDB::pathToObjectInternal(const root_list &list, const char *path
return NULL; return NULL;
} }
int QListDB::acceptFilteredObject(const CMAObject *parent, const CMAObject *current, int type) int QListDB::acceptFilteredObject(const CMAObject *obj_parent, const CMAObject *current, int type)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
int result = 0; int result = 0;
@@ -347,7 +347,7 @@ int QListDB::acceptFilteredObject(const CMAObject *parent, const CMAObject *curr
} else if(type & (VITA_DIR_TYPE_MASK_ALL | VITA_DIR_TYPE_MASK_SONGS)) { } else if(type & (VITA_DIR_TYPE_MASK_ALL | VITA_DIR_TYPE_MASK_SONGS)) {
result = result && (current->metadata.dataType & File); result = result && (current->metadata.dataType & File);
} else if(type & (VITA_DIR_TYPE_MASK_REGULAR)) { } else if(type & (VITA_DIR_TYPE_MASK_REGULAR)) {
result = (parent->metadata.ohfi == current->metadata.ohfiParent); result = (obj_parent->metadata.ohfi == current->metadata.ohfiParent);
} }
// TODO: Support other filter types // TODO: Support other filter types
@@ -420,26 +420,26 @@ int QListDB::getObjectMetadatas(int parent_ohfi, metadata_t **metadata, int inde
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
CMARootObject *parent = static_cast<CMARootObject *>(ohfiToObject(parent_ohfi)); CMARootObject *obj_parent = static_cast<CMARootObject *>(ohfiToObject(parent_ohfi));
if(parent == NULL) { if(obj_parent == NULL) {
return 0; return 0;
} }
if(parent->metadata.dataType & File) { if(obj_parent->metadata.dataType & File) {
*metadata = &parent->metadata; *metadata = &obj_parent->metadata;
return 1; return 1;
} }
int type = parent->metadata.type; int type = obj_parent->metadata.type;
if(parent->metadata.ohfi < OHFI_OFFSET && parent->filters) { // if we have filters if(obj_parent->metadata.ohfi < OHFI_OFFSET && obj_parent->filters) { // if we have filters
if(parent_ohfi == parent->metadata.ohfi) { // if we are looking at root if(parent_ohfi == obj_parent->metadata.ohfi) { // if we are looking at root
return parent->getFilters(metadata); return obj_parent->getFilters(metadata);
} else { // we are looking at a filter } else { // we are looking at a filter
for(int j = 0; j < parent->num_filters; j++) { for(int j = 0; j < obj_parent->num_filters; j++) {
if(parent->filters[j].ohfi == parent_ohfi) { if(obj_parent->filters[j].ohfi == parent_ohfi) {
type = parent->filters[j].type; type = obj_parent->filters[j].type;
break; break;
} }
} }
@@ -453,7 +453,7 @@ int QListDB::getObjectMetadatas(int parent_ohfi, metadata_t **metadata, int inde
for(map_list::iterator root = object_list.begin(); root != object_list.end(); ++root) { for(map_list::iterator root = object_list.begin(); root != object_list.end(); ++root) {
for(root_list::iterator object = (*root).begin(); object != (*root).end(); ++object) { for(root_list::iterator object = (*root).begin(); object != (*root).end(); ++object) {
if(acceptFilteredObject(parent, *object, type)) { if(acceptFilteredObject(obj_parent, *object, type)) {
if(offset++ >= index) { if(offset++ >= index) {
tail->next_metadata = &(*object)->metadata; tail->next_metadata = &(*object)->metadata;
tail = tail->next_metadata; tail = tail->next_metadata;
@@ -538,7 +538,7 @@ QString QListDB::getAbsolutePath(int ohfi)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
CMAObject *obj = ohfiToObject(ohfi); CMAObject *obj = ohfiToObject(ohfi);
return obj ? obj->path : NULL; return obj ? obj->m_path : NULL;
} }
QString QListDB::getRelativePath(int ohfi) QString QListDB::getRelativePath(int ohfi)

72
src/sqlitedb.cpp
View File

@@ -145,10 +145,10 @@ static const int ohfi_array[] = { VITA_OHFI_MUSIC, VITA_OHFI_PHOTO, VITA_OHFI_VI
VITA_OHFI_PSPSAVE, VITA_OHFI_PSXAPP, VITA_OHFI_PSMAPP VITA_OHFI_PSPSAVE, VITA_OHFI_PSXAPP, VITA_OHFI_PSMAPP
}; };
SQLiteDB::SQLiteDB(QObject *parent) : SQLiteDB::SQLiteDB(QObject *obj_parent) :
Database(parent) Database(obj_parent)
{ {
uuid = QSettings().value("lastAccountId", "ffffffffffffffff").toString(); m_uuid = QSettings().value("lastAccountId", "ffffffffffffffff").toString();
thread = new QThread(); thread = new QThread();
moveToThread(thread); moveToThread(thread);
timer = new QTimer(); timer = new QTimer();
@@ -179,7 +179,7 @@ SQLiteDB::~SQLiteDB()
void SQLiteDB::setUUID(const QString &uuid) void SQLiteDB::setUUID(const QString &uuid)
{ {
this->uuid = uuid; m_uuid = uuid;
QSettings().setValue("lastAccountId", uuid); QSettings().setValue("lastAccountId", uuid);
} }
@@ -209,7 +209,7 @@ bool SQLiteDB::load()
bool SQLiteDB::rescan() bool SQLiteDB::rescan()
{ {
if(mutex.tryLock(1000)) { if(mutex.tryLock(1000)) {
if(uuid != "ffffffffffffffff") { if(m_uuid != "ffffffffffffffff") {
timer->start(); timer->start();
return true; return true;
} else { } else {
@@ -304,22 +304,22 @@ QString SQLiteDB::getBasePath(int root_ohfi)
base_path = settings.value("photoPath").toString(); base_path = settings.value("photoPath").toString();
break; break;
case VITA_OHFI_BACKUP: case VITA_OHFI_BACKUP:
base_path = settings.value("appsPath").toString() + "/SYSTEM/" + uuid; base_path = settings.value("appsPath").toString() + "/SYSTEM/" + m_uuid;
break; break;
case VITA_OHFI_VITAAPP: case VITA_OHFI_VITAAPP:
base_path = settings.value("appsPath").toString() + "/APP/" + uuid; base_path = settings.value("appsPath").toString() + "/APP/" + m_uuid;
break; break;
case VITA_OHFI_PSPAPP: case VITA_OHFI_PSPAPP:
base_path = settings.value("appsPath").toString() + "/PGAME/" + uuid; base_path = settings.value("appsPath").toString() + "/PGAME/" + m_uuid;
break; break;
case VITA_OHFI_PSPSAVE: case VITA_OHFI_PSPSAVE:
base_path = settings.value("appsPath").toString() + "/PSAVEDATA/" + uuid; base_path = settings.value("appsPath").toString() + "/PSAVEDATA/" + m_uuid;
break; break;
case VITA_OHFI_PSXAPP: case VITA_OHFI_PSXAPP:
base_path = settings.value("appsPath").toString() + "/PSGAME/" + uuid; base_path = settings.value("appsPath").toString() + "/PSGAME/" + m_uuid;
break; break;
case VITA_OHFI_PSMAPP: case VITA_OHFI_PSMAPP:
base_path = settings.value("appsPath").toString() + "/PSM/" + uuid; base_path = settings.value("appsPath").toString() + "/PSM/" + m_uuid;
break; break;
} }
return base_path; return base_path;
@@ -463,11 +463,11 @@ bool SQLiteDB::deleteEntry(int ohfi)
return ret; return ret;
} }
bool SQLiteDB::updateAdjacencyList(int ohfi, int parent) bool SQLiteDB::updateAdjacencyList(int ohfi, int id_parent)
{ {
QSqlQuery query; QSqlQuery query;
query.prepare("SELECT * FROM adjacent_objects WHERE parent_id == :parent_id AND child_id == :child_id"); query.prepare("SELECT * FROM adjacent_objects WHERE parent_id == :parent_id AND child_id == :child_id");
query.bindValue(0, parent); query.bindValue(0, id_parent);
query.bindValue(1, ohfi); query.bindValue(1, ohfi);
if(query.exec() && query.next()) { if(query.exec() && query.next()) {
@@ -476,7 +476,7 @@ bool SQLiteDB::updateAdjacencyList(int ohfi, int parent)
query.prepare("INSERT INTO adjacent_objects (parent_id, child_id)" query.prepare("INSERT INTO adjacent_objects (parent_id, child_id)"
"VALUES (:parentid, :child_id)"); "VALUES (:parentid, :child_id)");
query.bindValue(0, parent); query.bindValue(0, id_parent);
query.bindValue(1, ohfi); query.bindValue(1, ohfi);
bool ret = query.exec(); bool ret = query.exec();
if(!ret) { if(!ret) {
@@ -485,7 +485,7 @@ bool SQLiteDB::updateAdjacencyList(int ohfi, int parent)
return ret; return ret;
} }
int SQLiteDB::insertDefaultEntry(const QString &path, const QString &name, const QString &title, int parent, int type) int SQLiteDB::insertDefaultEntry(const QString &path, const QString &name, const QString &title, int id_parent, int type)
{ {
int ohfi = 0; int ohfi = 0;
@@ -493,7 +493,7 @@ int SQLiteDB::insertDefaultEntry(const QString &path, const QString &name, const
return 0; return 0;
} }
if(parent >= OHFI_BASE_VALUE && !updateAdjacencyList(ohfi, parent)) { if(id_parent >= OHFI_BASE_VALUE && !updateAdjacencyList(ohfi, id_parent)) {
return 0; return 0;
} }
@@ -550,7 +550,7 @@ bool SQLiteDB::insertSourceEntry(uint object_id, const QString &path, const QStr
return ret; return ret;
} }
uint SQLiteDB::insertMusicEntry(const QString &path, const QString &name, int parent, int type) uint SQLiteDB::insertMusicEntry(const QString &path, const QString &name, int id_parent, int type)
{ {
bool ok; bool ok;
int ohfi; int ohfi;
@@ -559,8 +559,8 @@ uint SQLiteDB::insertMusicEntry(const QString &path, const QString &name, int pa
const char *artist, *album, *albumartist, *genre, *track, *title; const char *artist, *album, *albumartist, *genre, *track, *title;
int file_format, audio_codec, audio_bitrate, genre_id, artist_id, track_id, album_id, track_number; int file_format, audio_codec, audio_bitrate, genre_id, artist_id, track_id, album_id, track_number;
int file_type = checkFileType(name, VITA_OHFI_MUSIC); int cma_file_type = checkFileType(name, VITA_OHFI_MUSIC);
if(file_type < 0) { if(cma_file_type < 0) {
//qDebug() << "Excluding from database:" << path; //qDebug() << "Excluding from database:" << path;
return 0; return 0;
} }
@@ -589,13 +589,13 @@ uint SQLiteDB::insertMusicEntry(const QString &path, const QString &name, int pa
duration = decoder.getDuration(); duration = decoder.getDuration();
file_format = audio_list[file_type].file_format; file_format = audio_list[cma_file_type].file_format;
audio_codec = audio_list[file_type].file_codec; audio_codec = audio_list[cma_file_type].file_codec;
QByteArray basename = QFileInfo(name).baseName().toUtf8(); QByteArray basename = QFileInfo(name).baseName().toUtf8();
title = decoder.getMetadataEntry("title", basename.constData()); title = decoder.getMetadataEntry("title", basename.constData());
if((ohfi = insertDefaultEntry(path, name, title, parent, type)) == 0) { if((ohfi = insertDefaultEntry(path, name, title, id_parent, type)) == 0) {
return 0; return 0;
} }
@@ -667,7 +667,7 @@ uint SQLiteDB::insertMusicEntry(const QString &path, const QString &name, int pa
return ohfi; return ohfi;
} }
uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int parent, int type) uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int id_parent, int type)
{ {
int ohfi; int ohfi;
AVDecoder decoder; AVDecoder decoder;
@@ -679,8 +679,8 @@ uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int pa
return 0; return 0;
} }
int file_type = checkFileType(name, VITA_OHFI_VIDEO); int cma_file_type = checkFileType(name, VITA_OHFI_VIDEO);
if(file_type < 0) { if(cma_file_type < 0) {
//qDebug() << "Excluding from database:" << path; //qDebug() << "Excluding from database:" << path;
return 0; return 0;
} }
@@ -693,7 +693,7 @@ uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int pa
duration = decoder.getDuration(); duration = decoder.getDuration();
video_codec = CODEC_TYPE_AVC; video_codec = CODEC_TYPE_AVC;
video_bitrate = decoder.getBitrate(); video_bitrate = decoder.getBitrate();
file_format = video_list[file_type].file_format; file_format = video_list[cma_file_type].file_format;
if(decoder.loadCodec(AVDecoder::CODEC_AUDIO)) { if(decoder.loadCodec(AVDecoder::CODEC_AUDIO)) {
audio_codec = CODEC_TYPE_AAC; audio_codec = CODEC_TYPE_AAC;
@@ -708,7 +708,7 @@ uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int pa
title = basename.constData(); title = basename.constData();
if((ohfi = insertDefaultEntry(path, name, title, parent, type)) == 0) { if((ohfi = insertDefaultEntry(path, name, title, id_parent, type)) == 0) {
return 0; return 0;
} }
@@ -738,15 +738,15 @@ uint SQLiteDB::insertVideoEntry(const QString &path, const QString &name, int pa
return ohfi; return ohfi;
} }
uint SQLiteDB::insertPhotoEntry(const QString &path, const QString &name, int parent, int type) uint SQLiteDB::insertPhotoEntry(const QString &path, const QString &name, int id_parent, int type)
{ {
int ohfi; int ohfi;
QImage img; QImage img;
uint date_created; uint date_created;
int width, height, file_format, photo_codec; int width, height, file_format, photo_codec;
int file_type = checkFileType(name, VITA_OHFI_PHOTO); int cma_file_type = checkFileType(name, VITA_OHFI_PHOTO);
if(file_type < 0) { if(cma_file_type < 0) {
//qDebug() << "Excluding from database:" << path; //qDebug() << "Excluding from database:" << path;
return 0; return 0;
} }
@@ -761,12 +761,12 @@ uint SQLiteDB::insertPhotoEntry(const QString &path, const QString &name, int pa
width = img.width(); width = img.width();
height = img.height(); height = img.height();
file_format = photo_list[file_type].file_format; file_format = photo_list[cma_file_type].file_format;
photo_codec = photo_list[file_type].file_codec; photo_codec = photo_list[cma_file_type].file_codec;
QByteArray basename = QFileInfo(name).baseName().toUtf8(); QByteArray basename = QFileInfo(name).baseName().toUtf8();
if((ohfi = insertDefaultEntry(path, name, basename, parent, type)) == 0) { if((ohfi = insertDefaultEntry(path, name, basename, id_parent, type)) == 0) {
return 0; return 0;
} }
@@ -790,7 +790,7 @@ uint SQLiteDB::insertPhotoEntry(const QString &path, const QString &name, int pa
return ohfi; return ohfi;
} }
uint SQLiteDB::insertSavedataEntry(const QString &path, const QString &name, int parent, int type) uint SQLiteDB::insertSavedataEntry(const QString &path, const QString &name, int id_parent, int type)
{ {
int ohfi; int ohfi;
SfoReader reader; SfoReader reader;
@@ -809,7 +809,7 @@ uint SQLiteDB::insertSavedataEntry(const QString &path, const QString &name, int
date_updated = QFileInfo(path + "/" + name).lastModified().toUTC().toTime_t(); date_updated = QFileInfo(path + "/" + name).lastModified().toUTC().toTime_t();
} }
if((ohfi = insertDefaultEntry(path, name, title, parent, type)) == 0) { if((ohfi = insertDefaultEntry(path, name, title, id_parent, type)) == 0) {
return 0; return 0;
} }
@@ -822,7 +822,7 @@ uint SQLiteDB::insertSavedataEntry(const QString &path, const QString &name, int
"(object_id, detail, dir_name, title, date_updated)" "(object_id, detail, dir_name, title, date_updated)"
"VALUES (:object_id, :detail, :dir_name, :title, :updated)"); "VALUES (:object_id, :detail, :dir_name, :title, :updated)");
query.bindValue(0, parent); query.bindValue(0, id_parent);
query.bindValue(1, savedata_detail); query.bindValue(1, savedata_detail);
query.bindValue(2, savedata_directory); query.bindValue(2, savedata_directory);
query.bindValue(3, title); query.bindValue(3, title);

4
src/sqlitedb.h
View File

@@ -42,7 +42,7 @@ public:
void close(); void close();
bool reload(bool &prepared); bool reload(bool &prepared);
void setUUID(const QString &uuid); void setUUID(const QString &m_uuid);
bool open(); bool open();
int create(); int create();
@@ -95,7 +95,7 @@ private:
QTimer *timer; QTimer *timer;
QThread *thread; QThread *thread;
QString uuid; QString m_uuid;
QSqlDatabase db; QSqlDatabase db;
}; };