Differential D15277 Diff 43074 mtp/kiod_module/mtpstorage.cpp

Changeset View

Standalone View

View Options

mtp/kiod_module/mtpstorage.cpp

  • This file was added.
1​/*
2​ This file is part of the MTP KIOD module, part of the KDE project.
3​
4​ Copyright (C) 2018 Andreas Krutzler <andreas.krutzler@gmx.net>
5​
6​ This program is free software: you can redistribute it and/or modify
7​ it under the terms of the GNU General Public License as published by
8​ the Free Software Foundation, either version 2 of the License, or
9​ (at your option) any later version.
10​
11​ This program is distributed in the hope that it will be useful,
12​ but WITHOUT ANY WARRANTY; without even the implied warranty of
13​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14​ GNU General Public License for more details.
15​
16​ You should have received a copy of the GNU General Public License
17​ along with this program. If not, see <http://www.gnu.org/licenses/>.
18​*/
19​
20​#include "mtpstorage.h"
21​
22​#include <QDateTime>
23​#include <qplatformdefs.h>
24​
25​#include "mtpdevice.h"
26​#include "storageadaptor.h"
27​
28​/**
29​ * @brief MTPDataPutFunc callback function, "puts" data from the device somewhere else
30​ */
31​static uint16_t onDataPut(void *, void *priv, uint32_t sendlen, unsigned char *data, uint32_t *putlen)
32​{
dfaureUnsubmitted
Not Done

Prepend "static" to all these class-level functions (so they don't get exported, and so that the compiler knows they are only usable in this file, which can lead to more optimizations like inlining).

dfaure: Prepend "static" to all these class-level functions (so they don't get exported, and so that…
33​ MTPStorage *storage = static_cast<MTPStorage *>(priv);
34​ emit storage->dataReady(QByteArray(reinterpret_cast<char *>(data), int(sendlen)));
35​ *putlen = sendlen;
36​
37​ return LIBMTP_HANDLER_RETURN_OK;
38​}
39​
40​static int onDataProgress(const uint64_t sent, const uint64_t total, const void * const priv)
41​{
42​ MTPStorage *storage = const_cast<MTPStorage *>(static_cast<const MTPStorage *>(priv));
43​ emit storage->copyProgress(sent, total);
44​ return LIBMTP_HANDLER_RETURN_OK;
45​}
46​
47​static QString convertToPath(const QStringList &pathItems, const int elements)
48​{
49​ QString path;
50​
51​ for (int i = 0; i < elements && elements <= pathItems.size(); i++) {
52​ path.append(QLatin1Char('/'));
53​ path.append(pathItems.at(i));
54​ }
55​
56​ return path;
57​}
58​
59​/**
60​ * @brief Converts a mime-type to a LIBMTP_filetype_t
61​ */
62​static LIBMTP_filetype_t getFiletype(const QString &filename)
63​{
64​ LIBMTP_filetype_t filetype;
65​
66​ const QString ptype = filename.split(QLatin1Char('.')).last();
67​
68​ /* This need to be kept constantly updated as new file types arrive. */
69​ if (ptype == QLatin1String("wav")) {
70​ filetype = LIBMTP_FILETYPE_WAV;
71​ } else if (ptype == QLatin1String("mp3")) {
72​ filetype = LIBMTP_FILETYPE_MP3;
73​ } else if (ptype == QLatin1String("wma")) {
74​ filetype = LIBMTP_FILETYPE_WMA;
75​ } else if (ptype == QLatin1String("ogg")) {
76​ filetype = LIBMTP_FILETYPE_OGG;
77​ } else if (ptype == QLatin1String("mp4")) {
78​ filetype = LIBMTP_FILETYPE_MP4;
79​ } else if (ptype == QLatin1String("wmv")) {
80​ filetype = LIBMTP_FILETYPE_WMV;
81​ } else if (ptype == QLatin1String("avi")) {
82​ filetype = LIBMTP_FILETYPE_AVI;
83​ } else if (ptype == QLatin1String("mpeg") ||
84​ ptype == QLatin1String("mpg")) {
85​ filetype = LIBMTP_FILETYPE_MPEG;
86​ } else if (ptype == QLatin1String("asf")) {
87​ filetype = LIBMTP_FILETYPE_ASF;
88​ } else if (ptype == QLatin1String("qt") ||
89​ ptype == QLatin1String("mov")) {
90​ filetype = LIBMTP_FILETYPE_QT;
91​ } else if (ptype == QLatin1String("wma")) {
92​ filetype = LIBMTP_FILETYPE_WMA;
93​ } else if (ptype == QLatin1String("jpg") ||
94​ ptype == QLatin1String("jpeg")) {
95​ filetype = LIBMTP_FILETYPE_JPEG;
96​ } else if (ptype == QLatin1String("jfif")) {
97​ filetype = LIBMTP_FILETYPE_JFIF;
98​ } else if (ptype == QLatin1String("tif") ||
99​ ptype == QLatin1String("tiff")) {
100​ filetype = LIBMTP_FILETYPE_TIFF;
101​ } else if (ptype == QLatin1String("bmp")) {
102​ filetype = LIBMTP_FILETYPE_BMP;
103​ } else if (ptype == QLatin1String("gif")) {
104​ filetype = LIBMTP_FILETYPE_GIF;
105​ } else if (ptype == QLatin1String("pic") ||
106​ ptype == QLatin1String("pict")) {
107​ filetype = LIBMTP_FILETYPE_PICT;
108​ } else if (ptype == QLatin1String("png")) {
109​ filetype = LIBMTP_FILETYPE_PNG;
110​ } else if (ptype == QLatin1String("wmf")) {
111​ filetype = LIBMTP_FILETYPE_WINDOWSIMAGEFORMAT;
112​ } else if (ptype == QLatin1String("ics")) {
113​ filetype = LIBMTP_FILETYPE_VCALENDAR2;
114​ } else if (ptype == QLatin1String("exe") ||
115​ ptype == QLatin1String("com") ||
116​ ptype == QLatin1String("bat") ||
117​ ptype == QLatin1String("dll") ||
118​ ptype == QLatin1String("sys")) {
119​ filetype = LIBMTP_FILETYPE_WINEXEC;
120​ } else if (ptype == QLatin1String("aac")) {
121​ filetype = LIBMTP_FILETYPE_AAC;
122​ } else if (ptype == QLatin1String("mp2")) {
123​ filetype = LIBMTP_FILETYPE_MP2;
124​ } else if (ptype == QLatin1String("flac")) {
125​ filetype = LIBMTP_FILETYPE_FLAC;
126​ } else if (ptype == QLatin1String("m4a")) {
127​ filetype = LIBMTP_FILETYPE_M4A;
128​ } else if (ptype == QLatin1String("doc")) {
129​ filetype = LIBMTP_FILETYPE_DOC;
130​ } else if (ptype == QLatin1String("xml")) {
131​ filetype = LIBMTP_FILETYPE_XML;
132​ } else if (ptype == QLatin1String("xls")) {
133​ filetype = LIBMTP_FILETYPE_XLS;
134​ } else if (ptype == QLatin1String("ppt")) {
135​ filetype = LIBMTP_FILETYPE_PPT;
136​ } else if (ptype == QLatin1String("mht")) {
137​ filetype = LIBMTP_FILETYPE_MHT;
138​ } else if (ptype == QLatin1String("jp2")) {
139​ filetype = LIBMTP_FILETYPE_JP2;
140​ } else if (ptype == QLatin1String("jpx")) {
141​ filetype = LIBMTP_FILETYPE_JPX;
142​ } else if (ptype == QLatin1String("bin")) {
143​ filetype = LIBMTP_FILETYPE_FIRMWARE;
144​ } else if (ptype == QLatin1String("vcf")) {
145​ filetype = LIBMTP_FILETYPE_VCARD3;
146​ } else {
147​ /* Tagging as unknown file type */
148​ filetype = LIBMTP_FILETYPE_UNKNOWN;
149​ }
150​
151​ return filetype;
152​}
153​
154​/**
155​ * @brief Converts a LIBMTP_filetype_t to a mime-type
156​ */
157​static QString getMimetype(LIBMTP_filetype_t filetype)
158​{
159​ switch (filetype) {
160​ case LIBMTP_FILETYPE_FOLDER:
161​ return QStringLiteral("inode/directory");
162​
163​ case LIBMTP_FILETYPE_WAV:
164​ return QStringLiteral("audio/wav");
165​ case LIBMTP_FILETYPE_MP3:
166​ return QStringLiteral("audio/x-mp3");
167​ case LIBMTP_FILETYPE_WMA:
168​ return QStringLiteral("audio/x-ms-wma");
169​ case LIBMTP_FILETYPE_OGG:
170​ return QStringLiteral("audio/x-vorbis+ogg");
171​ case LIBMTP_FILETYPE_AUDIBLE:
172​ return QString();
173​ case LIBMTP_FILETYPE_MP4:
174​ return QStringLiteral("audio/mp4");
175​ case LIBMTP_FILETYPE_UNDEF_AUDIO:
176​ return QString();
177​ case LIBMTP_FILETYPE_WMV:
mlaurentUnsubmitted
Done

QString() directly no ?

mlaurent: QString() directly no ?
akrutzlerAuthorUnsubmitted
Not Done

Of course, thanks! :)

akrutzler: Of course, thanks! :)
178​ return QStringLiteral("video/x-ms-wmv");
179​ case LIBMTP_FILETYPE_AVI:
180​ return QStringLiteral("video/x-msvideo");
181​ case LIBMTP_FILETYPE_MPEG:
182​ return QStringLiteral("video/mpeg");
183​ case LIBMTP_FILETYPE_ASF:
184​ return QStringLiteral("video/x-ms-asf");
185​ case LIBMTP_FILETYPE_QT:
186​ return QStringLiteral("video/quicktime");
187​ case LIBMTP_FILETYPE_UNDEF_VIDEO:
188​ return QString();
189​ case LIBMTP_FILETYPE_JPEG:
mlaurentUnsubmitted
Done

Same

mlaurent: Same
190​ return QStringLiteral("image/jpeg");
191​ case LIBMTP_FILETYPE_JFIF:
192​ return QString();
193​ case LIBMTP_FILETYPE_TIFF:
194​ return QStringLiteral("image/tiff");
195​ case LIBMTP_FILETYPE_BMP:
196​ return QStringLiteral("image/bmp");
197​ case LIBMTP_FILETYPE_GIF:
198​ return QStringLiteral("image/gif");
199​ case LIBMTP_FILETYPE_PICT:
200​ return QStringLiteral("image/x-pict");
201​ case LIBMTP_FILETYPE_PNG:
202​ return QStringLiteral("image/png");
203​ case LIBMTP_FILETYPE_VCALENDAR1:
204​ return QStringLiteral("text/x-vcalendar");
205​ case LIBMTP_FILETYPE_VCALENDAR2:
206​ return QStringLiteral("text/x-vcalendar");
207​ case LIBMTP_FILETYPE_VCARD2:
dfaureUnsubmitted
Done

Any chance currentDateTimeUtc could be used everywhere? It's much faster than currentDateTime because it doesn't need to do timezone conversions (which use the awful process-global tzset()).

Just a thought, maybe you do need local times.

dfaure: Any chance currentDateTimeUtc could be used everywhere? It's much faster than currentDateTime…
208​ return QStringLiteral("text/x-vcard");
209​ case LIBMTP_FILETYPE_VCARD3:
210​ return QStringLiteral("text/x-vcard");
211​ case LIBMTP_FILETYPE_WINDOWSIMAGEFORMAT:
212​ return QStringLiteral("image/x-wmf");
213​ case LIBMTP_FILETYPE_WINEXEC:
214​ return QStringLiteral("application/x-ms-dos-executable");
215​ case LIBMTP_FILETYPE_TEXT:
216​ return QStringLiteral("text/plain");
217​ case LIBMTP_FILETYPE_HTML:
218​ return QStringLiteral("text/html");
219​ case LIBMTP_FILETYPE_FIRMWARE:
220​ return QString();
221​ case LIBMTP_FILETYPE_AAC:
222​ return QStringLiteral("audio/aac");
223​ case LIBMTP_FILETYPE_MEDIACARD:
224​ return QString();
225​ case LIBMTP_FILETYPE_FLAC:
226​ return QStringLiteral("audio/flac");
dfaureUnsubmitted
Not Done

This method could be made much faster by locating the Nth slash and then using left(), to avoid the many reallocations due to multiple appends. Not sure it matters though.

dfaure: This method could be made much faster by locating the Nth slash and then using left(), to avoid…
227​ case LIBMTP_FILETYPE_MP2:
228​ return QStringLiteral("video/mpeg");
229​ case LIBMTP_FILETYPE_M4A:
230​ return QStringLiteral("audio/mp4");
231​ case LIBMTP_FILETYPE_DOC:
232​ return QStringLiteral("application/msword");
233​ case LIBMTP_FILETYPE_XML:
234​ return QStringLiteral("text/xml");
235​ case LIBMTP_FILETYPE_XLS:
236​ return QStringLiteral("application/vnd.ms-excel");
237​ case LIBMTP_FILETYPE_PPT:
238​ return QStringLiteral("application/vnd.ms-powerpoint");
239​ case LIBMTP_FILETYPE_MHT:
240​ return QString();
241​ case LIBMTP_FILETYPE_JP2:
mlaurentUnsubmitted
Done

same

mlaurent: same
242​ return QStringLiteral("image/jpeg2000");
243​ case LIBMTP_FILETYPE_JPX:
244​ return QStringLiteral("application/x-jbuilder-project");
245​ case LIBMTP_FILETYPE_UNKNOWN:
246​ default:
247​ return QString();
248​ }
249​}
250​
251​/**
252​ * @brief Creates @ref KMTPFile from LIBMTP_file_t
253​ *
254​ * @param file Must not be a nullptr!
255​ */
256​static KMTPFile createMTPFile(const LIBMTP_file_t *file)
257​{
dfaureUnsubmitted
Done

Minor: this would be more readable with a MTPStorage * local variable, i.e. splitting this over two lines.

dfaure: Minor: this would be more readable with a MTPStorage * local variable, i.e. splitting this over…
258​ return KMTPFile(file->item_id,
259​ file->parent_id,
260​ file->storage_id,
261​ file->filename,
262​ file->filesize,
263​ file->modificationdate,
264​ getMimetype(file->filetype));
265​}
266​
267​MTPStorage::MTPStorage(const QString &dbusObjectPath, const LIBMTP_devicestorage_t *mtpStorage, MTPDevice *parent)
268​ : QObject(parent),
269​ m_dbusObjectPath(dbusObjectPath)
270​{
271​ setStorageProperties(mtpStorage);
272​
273​ qDBusRegisterMetaType<KMTPFile>();
274​ qDBusRegisterMetaType<KMTPFileList>();
275​
276​ new StorageAdaptor(this);
277​ QDBusConnection::sessionBus().registerObject(m_dbusObjectPath, this);
278​}
279​
280​QString MTPStorage::dbusObjectPath() const
281​{
282​ return m_dbusObjectPath;
283​}
284​
285​QString MTPStorage::description() const
286​{
287​ return m_description;
288​}
289​
290​quint64 MTPStorage::maxCapacity() const
291​{
292​ return m_maxCapacity;
293​}
294​
295​quint64 MTPStorage::freeSpaceInBytes()
296​{
297​ updateStorageInfo();
298​ return m_freeSpaceInBytes;
299​}
300​
301​void MTPStorage::setStorageProperties(const LIBMTP_devicestorage_t *storage)
302​{
303​ m_id = storage->id;
304​ m_maxCapacity = storage->MaxCapacity;
305​ m_freeSpaceInBytes = storage->FreeSpaceInBytes;
306​ m_description = QString::fromUtf8(storage->StorageDescription);
307​}
308​
309​void MTPStorage::updateStorageInfo()
310​{
311​ if (!LIBMTP_Get_Storage(getDevice(), LIBMTP_STORAGE_SORTBY_NOTSORTED)) {
312​ for (const LIBMTP_devicestorage_t *storage = getDevice()->storage; storage != nullptr; storage = storage->next) {
313​ if (m_id == storage->id) {
314​ qCDebug(LOG_KIOD_KMTPD) << "storage info updated";
315​ setStorageProperties(storage);
316​ break;
317​ }
318​ }
319​ }
320​}
321​
322​LIBMTP_mtpdevice_t *MTPStorage::getDevice() const
323​{
324​ return static_cast<MTPDevice *>(parent())->getDevice();
325​}
326​
327​KMTPFile MTPStorage::getFileFromPath(const QString &path)
328​{
329​ const QStringList pathItems = path.split(QLatin1Char('/'), QString::SkipEmptyParts);
330​
331​ // don't handle the root directory
332​ if (!pathItems.isEmpty()) {
333​
334​ // 1. check if the file is in the cache
335​ const quint32 itemId = queryPath(path);
336​ if (itemId) {
337​ qCDebug(LOG_KIOD_KMTPD) << "Match found in cache, checking device";
338​
339​ LIBMTP_file_t *file = LIBMTP_Get_Filemetadata(getDevice(), itemId);
340​ if (file) {
341​ qCDebug(LOG_KIOD_KMTPD) << "Found file in cache";
342​ const KMTPFile mtpFile = createMTPFile(file);
343​ LIBMTP_destroy_file_t(file);
344​ return mtpFile;
345​ }
346​ }
347​
348​ // 2. query cache for parent
349​ else if (pathItems.size() > 1) {
350​ QString parentPath = convertToPath(pathItems, pathItems.size() - 1);
351​ quint32 parentId = queryPath(parentPath);
352​
353​ qCDebug(LOG_KIOD_KMTPD) << "Match for parent found in cache, checking device. Parent id = " << parentId;
354​
355​ LIBMTP_file_t *parent = LIBMTP_Get_Filemetadata(getDevice(), parentId);
356​ if (parent) {
357​ qCDebug(LOG_KIOD_KMTPD) << "Found parent in cache";
358​
359​ const KMTPFileList list = getFilesAndFoldersCached(parentPath, parentId);
360​ const auto it = std::find_if(list.constBegin(), list.constEnd(), [pathItems](const KMTPFile & file) {
361​ return file.filename() == pathItems.last();
362​ });
363​
364​ LIBMTP_destroy_file_t(parent);
365​ if (it != list.constEnd()) {
366​ qCDebug(LOG_KIOD_KMTPD) << "Found file from cached parent";
367​ return *it;
368​ }
369​ }
370​ }
371​ }
372​
373​ // 3. traverse further while depth not reached
374​ QString currentPath;
375​ quint32 currentParent = LIBMTP_FILES_AND_FOLDERS_ROOT;
376​
377​ for (const QString &element : pathItems) {
378​ const KMTPFileList list = getFilesAndFoldersCached(currentPath, currentParent);
379​ auto it = std::find_if(list.constBegin(), list.constEnd(), [element] (const KMTPFile &file) {
380​ return file.filename() == element;
381​ });
382​
383​ if (it != list.constEnd()) {
384​ currentParent = it->itemId();
385​ } else {
386​ qCDebug(LOG_KIOD_KMTPD) << "File not found!";
387​ return KMTPFile();
388​ }
389​ currentPath.append(QLatin1Char('/') + element);
390​ }
391​
392​ LIBMTP_file_t *file = LIBMTP_Get_Filemetadata(getDevice(), currentParent);
393​ if (file) {
394​ qCDebug(LOG_KIOD_KMTPD) << "Found file using tree walk";
395​
396​ const KMTPFile mtpFile = createMTPFile(file);
397​ LIBMTP_destroy_file_t(file);
398​ return mtpFile;
399​ }
400​ return KMTPFile();
401​}
402​
403​KMTPFileList MTPStorage::getFilesAndFoldersCached(const QString &path, quint32 parentId)
404​{
405​ KMTPFileList mtpFiles;
406​
407​ LIBMTP_file_t *tmp = nullptr;
408​ LIBMTP_file_t *file = LIBMTP_Get_Files_And_Folders(getDevice(), m_id, parentId);
409​ while (file != nullptr) {
410​ const KMTPFile mtpFile = createMTPFile(file);
411​ addPath(path + QLatin1Char('/') + mtpFile.filename(), mtpFile.itemId());
412​ mtpFiles.append(mtpFile);
413​
414​ tmp = file;
415​ file = file->next;
416​ LIBMTP_destroy_file_t(tmp);
417​ }
418​ return mtpFiles;
419​}
420​
421​quint32 MTPStorage::queryPath(const QString &path, int timeToLive)
422​{
423​ QPair< QDateTime, uint32_t > item = m_cache.value(path);
424​
425​ if (item.second != 0) {
426​ QDateTime dateTime = QDateTime::currentDateTimeUtc();
427​
428​ if (item.first > dateTime) {
429​ item.first = dateTime.addSecs(timeToLive);
430​ m_cache.insert(path, item);
431​ return item.second;
432​ } else {
433​ m_cache.remove(path);
434​ return 0;
435​ }
436​ }
437​
438​ return 0;
439​}
440​
441​void MTPStorage::addPath(const QString &path, quint32 id, int timeToLive)
442​{
443​ QDateTime dateTime = QDateTime::currentDateTimeUtc();
444​ dateTime = dateTime.addSecs(timeToLive);
445​
446​ QPair< QDateTime, uint32_t > item(dateTime, id);
447​
448​ m_cache.insert(path, item);
449​}
450​
451​void MTPStorage::removePath(const QString &path)
452​{
453​ m_cache.remove(path);
454​}
455​
456​KMTPFileList MTPStorage::getFilesAndFolders(const QString &path, int &result)
457​{
458​ result = 0;
459​ if (path.isEmpty() || path == QLatin1String("/")) {
460​ // list root directory
461​ return getFilesAndFoldersCached(path, LIBMTP_FILES_AND_FOLDERS_ROOT);
462​ }
463​ const KMTPFile file = getFileFromPath(path);
464​ if (!file.isValid()) {
465​ result = 1; // not existing
466​ return KMTPFileList();
467​ } else if (!file.isFolder()) {
468​ result = 2; // is file
469​ return KMTPFileList();
470​ }
471​ return getFilesAndFoldersCached(path, file.itemId());
472​}
473​
474​KMTPFile MTPStorage::getFileMetadata(const QString &path)
dfaureUnsubmitted
Done

Please remove Q_FUNC_INFO everywhere.

dfaure: Please remove Q_FUNC_INFO everywhere.
475​{
476​ qCDebug(LOG_KIOD_KMTPD) << "getFileMetadata:" << path;
477​ return getFileFromPath(path);
478​}
479​
480​int MTPStorage::getFileToHandler(const QString &path)
481​{
482​ qCDebug(LOG_KIOD_KMTPD) << "getFileToHandler:" << path;
483​
484​ const KMTPFile source = getFileMetadata(path);
485​ if (source.isValid()) {
486​ const quint32 itemId = source.itemId();
487​ QTimer::singleShot(0, this, [this, itemId] {
488​ const int result = LIBMTP_Get_File_To_Handler(getDevice(), itemId, onDataPut, this, onDataProgress, this);
489​ if (result) {
490​ LIBMTP_Dump_Errorstack(getDevice());
491​ LIBMTP_Clear_Errorstack(getDevice());
492​ }
493​ emit copyFinished(result);
494​ });
495​ return 0;
496​ }
497​ return 1;
498​}
499​
500​int MTPStorage::getFileToFileDescriptor(const QDBusUnixFileDescriptor &descriptor, const QString &sourcePath)
dfaureUnsubmitted
Not Done

DBus timeouts are actually configurable, if you need to block until the copy is done, btw.

dfaure: DBus timeouts are actually configurable, if you need to block until the copy is done, btw.
akrutzlerAuthorUnsubmitted
Not Done

In my previous approach I increased the timeout to 10 minutes. This worked fine until I downloaded a file of about 10GB or so from my phone -> timeout. It's hard to find a proper timeout which is why I chose the async way. :)

akrutzler: In my previous approach I increased the timeout to 10 minutes. This worked fine until I…
501​{
502​ qCDebug(LOG_KIOD_KMTPD) << "getFileToFileDescriptor:" << sourcePath;
503​
504​ const KMTPFile source = getFileMetadata(sourcePath);
505​ if (source.isValid()) {
506​ const quint32 itemId = source.itemId();
507​
508​ // big files take some time to copy, and this may lead into D-Bus timeouts.
509​ // therefore the actual copying is not done within the D-Bus method itself but right after we return to the event loop
510​ QTimer::singleShot(0, this, [this, itemId, descriptor] {
511​ const int result = LIBMTP_Get_File_To_File_Descriptor(getDevice(), itemId, descriptor.fileDescriptor(), onDataProgress, this);
512​ if (result) {
513​ LIBMTP_Dump_Errorstack(getDevice());
514​ LIBMTP_Clear_Errorstack(getDevice());
515​ }
516​ emit copyFinished(result);
517​ });
518​ return 0;
519​ }
520​ return 1;
521​}
522​
523​int MTPStorage::sendFileFromFileDescriptor(const QDBusUnixFileDescriptor &descriptor, const QString &destinationPath)
524​{
525​ qCDebug(LOG_KIOD_KMTPD) << "sendFileFromFileDescriptor:" << destinationPath;
526​
527​ QStringList destItems = destinationPath.split(QLatin1Char('/'), QString::SkipEmptyParts);
528​ if (destItems.isEmpty()) {
529​ return 1;
530​ }
531​
532​ const QString filename = destItems.takeLast();
533​ uint32_t parentId = LIBMTP_FILES_AND_FOLDERS_ROOT;
534​
535​ if (!destItems.isEmpty()) {
536​ // not root folder, search for parent folder
537​ const KMTPFile parent = getFileMetadata(convertToPath(destItems, destItems.size()));
538​ parentId = parent.itemId();
539​ if (!parent.isFolder()) {
540​ return 2;
541​ }
542​ }
543​
544​ QTimer::singleShot(0, this, [this, parentId, descriptor, filename] {
545​ int result = 1;
546​ QT_STATBUF srcBuf;
547​ if (QT_FSTAT(descriptor.fileDescriptor(), &srcBuf) != -1) {
548​ const QDateTime lastModified = QDateTime::fromSecsSinceEpoch(srcBuf.st_mtim.tv_sec);
549​
550​ LIBMTP_file_t *file = LIBMTP_new_file_t();
551​ file->parent_id = parentId;
552​ file->filename = qstrdup(filename.toUtf8().data());
553​ file->filetype = getFiletype(filename);
554​ file->filesize = quint64(srcBuf.st_size);
555​ file->modificationdate = lastModified.toTime_t(); // no matter what to set here, current time is taken
556​ file->storage_id = m_id;
557​
558​ result = LIBMTP_Send_File_From_File_Descriptor(getDevice(), descriptor.fileDescriptor(), file, onDataProgress, this);
559​ LIBMTP_destroy_file_t(file);
560​
561​ if (result) {
562​ LIBMTP_Dump_Errorstack(getDevice());
563​ LIBMTP_Clear_Errorstack(getDevice());
564​ }
565​ }
566​ emit copyFinished(result);
567​ });
568​
569​ return 0;
570​}
571​
572​int MTPStorage::setFileName(const QString &path, const QString &newName)
573​{
574​ qCDebug(LOG_KIOD_KMTPD) << "setFileName:" << path << newName;
575​
576​ const KMTPFile file = getFileFromPath(path);
577​ if (file.isValid()) {
578​ LIBMTP_file_t *source = LIBMTP_Get_Filemetadata(getDevice(), file.itemId());
579​ if (source) {
580​ const int result = LIBMTP_Set_File_Name(getDevice(), source, newName.toUtf8().constData());
581​ if (!result) {
582​ removePath(path);
583​ LIBMTP_destroy_file_t(source);
584​ }
585​ return result;
586​ }
587​ }
588​ return 1;
589​}
590​
591​quint32 MTPStorage::createFolder(const QString &path)
592​{
593​ qCDebug(LOG_KIOD_KMTPD) << "createFolder:" << path;
594​
595​ quint32 folderId = 0;
596​ const QStringList pathItems = path.split(QLatin1Char('/'), QString::SkipEmptyParts);
597​ const quint32 destinationId = queryPath(path);
598​
599​ if (!pathItems.isEmpty() && !destinationId) {
600​ QByteArray dirName = pathItems.last().toUtf8();
601​
602​ if (pathItems.size() == 1) {
603​ // create folder in device root
604​ folderId = LIBMTP_Create_Folder(getDevice(), dirName.data(), LIBMTP_FILES_AND_FOLDERS_ROOT, m_id);
605​
606​ } else {
607​ const KMTPFile parentFolder = getFileMetadata(path.section(QLatin1Char('/'), 0, -2, QString::SectionIncludeLeadingSep));
608​ if (parentFolder.isFolder()) {
609​ folderId = LIBMTP_Create_Folder(getDevice(), dirName.data(), parentFolder.itemId(), m_id);
610​ }
611​ }
612​
613​ if (folderId) {
614​ LIBMTP_Dump_Errorstack(getDevice());
615​ LIBMTP_Clear_Errorstack(getDevice());
616​ } else {
617​ addPath(path, folderId);
618​ }
619​ }
620​ return folderId;
621​}
622​
623​int MTPStorage::deleteObject(const QString &path)
624​{
625​ qCDebug(LOG_KIOD_KMTPD) << "deleteObject:" << path;
626​
627​ const KMTPFile file = getFileMetadata(path);
628​ const int ret = LIBMTP_Delete_Object(getDevice(), file.itemId());
629​ if (!ret) {
630​ removePath(path);
631​ }
632​ return ret;
633​}
634​
635​#include "moc_mtpstorage.cpp"