bool MTPDevice::enumStorages() { criticalEnter(); LIBMTP_Clear_Errorstack(m_device); if (LIBMTP_Get_Storage(m_device, LIBMTP_STORAGE_SORTBY_NOTSORTED) < 0) { std::cerr << "Could not retrieve device storage.\n"; std::cerr << "For android phones make sure the screen is unlocked.\n"; logerr("Could not retrieve device storage. Exiting.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return false; } criticalLeave(); return true; }
int MTPDevice::dirRemove(const std::string &path) { const std::string tmp_basename(smtpfs_basename(path)); const std::string tmp_dirname(smtpfs_dirname(path)); const TypeDir *dir_parent = dirFetchContent(tmp_dirname); const TypeDir *dir_to_remove = dir_parent ? dir_parent->dir(tmp_basename) : nullptr; if (!dir_parent || !dir_to_remove || dir_parent->id() == 0) { logerr("No such directory '", path, "' to remove.\n"); return -ENOENT; } if (!dir_to_remove->isEmpty()) return -ENOTEMPTY; criticalEnter(); int rval = LIBMTP_Delete_Object(m_device, dir_to_remove->id()); criticalLeave(); if (rval != 0){ logerr("Could not remove the directory '", path, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -EINVAL; } const_cast<TypeDir*>(dir_parent)->removeDir(*dir_to_remove); logmsg("Folder '", path, "' removed.\n"); return 0; }
int main(int argc, char const *argv[]) { LIBMTP_Init(); printf("Searching for device...\n"); LIBMTP_mtpdevice_t* device = LIBMTP_Get_First_Device(); if (!device) { printf("Oops, no devices!\n"); return 1; } /* Warning! This id is just for test! Remove it and put your value */ const int id = 10494; int r = 0; LIBMTP_BeginEditObject(device, id); char s[64] = "The quick brown fox jumps over lazy dog\n"; printf("Calling for LIBMTP_SendPartialObject...\n"); r = LIBMTP_SendPartialObject(device, id, 0, (unsigned char *)s, strlen(s)); if (r < 0) { printf("Oops, an error!\n"); goto cleanup; } else printf("LIBMTP_SendPartialObject done successfully!\n"); LIBMTP_EndEditObject(device, id); cleanup: LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); LIBMTP_Release_Device(device); return r < 0 ? -1 : 0; }
int MTPDevice::dirCreateNew(const std::string &path) { const std::string tmp_basename(smtpfs_basename(path)); const std::string tmp_dirname(smtpfs_dirname(path)); const TypeDir *dir_parent = dirFetchContent(tmp_dirname); if (!dir_parent || dir_parent->id() == 0) { logerr("Can not remove directory '", path, "'.\n"); return -EINVAL; } char *c_name = strdup(tmp_basename.c_str()); criticalEnter(); uint32_t new_id = LIBMTP_Create_Folder(m_device, c_name, dir_parent->id(), dir_parent->storageid()); criticalLeave(); if (new_id == 0) { logerr("Could not create directory '", path, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); } else { const_cast<TypeDir*>(dir_parent)->addDir(TypeDir(new_id, dir_parent->id(), dir_parent->storageid(), tmp_basename)); logmsg("Directory '", path, "' created.\n"); } free(static_cast<void*>(c_name)); return new_id != 0 ? 0 : -EINVAL; }
int MTPDevice::dirRename(const std::string &oldpath, const std::string &newpath) { const std::string tmp_old_basename(smtpfs_basename(oldpath)); const std::string tmp_old_dirname(smtpfs_dirname(oldpath)); const std::string tmp_new_basename(smtpfs_basename(newpath)); const std::string tmp_new_dirname(smtpfs_dirname(newpath)); const TypeDir *dir_parent = dirFetchContent(tmp_old_dirname); const TypeDir *dir_to_rename = dir_parent ? dir_parent->dir(tmp_old_basename) : nullptr; if (!dir_parent || !dir_to_rename || dir_parent->id() == 0) { logerr("Can not rename '", tmp_old_basename, "' to '", tmp_new_basename, "'.\n"); return -EINVAL; } if (tmp_old_dirname != tmp_new_dirname) { logerr("Can not move '", oldpath, "' to '", newpath, "'.\n"); return -EINVAL; } LIBMTP_folder_t *folder = dir_to_rename->toLIBMTPFolder(); criticalEnter(); int ret = LIBMTP_Set_Folder_Name(m_device, folder, tmp_new_basename.c_str()); criticalLeave(); free(static_cast<void*>(folder->name)); free(static_cast<void*>(folder)); if (ret != 0) { logerr("Could not rename '", oldpath, "' to '", tmp_new_basename, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -EINVAL; } const_cast<TypeDir*>(dir_to_rename)->setName(tmp_new_basename); logmsg("Directory '", oldpath, "' renamed to '", tmp_new_basename, "'.\n"); return 0; }
int MTPDevice::filePull(const std::string &src, const std::string &dst) { const std::string src_basename(smtpfs_basename(src)); const std::string src_dirname(smtpfs_dirname(src)); const TypeDir *dir_parent = dirFetchContent(src_dirname); const TypeFile *file_to_fetch = dir_parent ? dir_parent->file(src_basename) : nullptr; if (!dir_parent) { logerr("Can not fetch '", src, "'.\n"); return -EINVAL; } if (!file_to_fetch) { logerr("No such file '", src, "'.\n"); return -ENOENT; } if (file_to_fetch->size() == 0) { int fd = ::creat(dst.c_str(), S_IRUSR | S_IWUSR); ::close(fd); } else { logmsg("Started fetching '", src, "'.\n"); criticalEnter(); int rval = LIBMTP_Get_File_To_File(m_device, file_to_fetch->id(), dst.c_str(), nullptr, nullptr); criticalLeave(); if (rval != 0) { logerr("Could not fetch file '", src, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -ENOENT; } } logmsg("File fetched '", src, "'.\n"); return 0; }
int MTPDevice::fileRename(const std::string &oldpath, const std::string &newpath) { const std::string tmp_old_basename(smtpfs_basename(oldpath)); const std::string tmp_old_dirname(smtpfs_dirname(oldpath)); const std::string tmp_new_basename(smtpfs_basename(newpath)); const std::string tmp_new_dirname(smtpfs_dirname(newpath)); const TypeDir *dir_parent = dirFetchContent(tmp_old_dirname); const TypeFile *file_to_rename = dir_parent ? dir_parent->file(tmp_old_basename) : nullptr; if (!dir_parent || !file_to_rename || tmp_old_dirname != tmp_new_dirname) { logerr("Can not rename '", oldpath, "' to '", tmp_new_basename, "'.\n"); return -EINVAL; } LIBMTP_file_t *file = file_to_rename->toLIBMTPFile(); criticalEnter(); int rval = LIBMTP_Set_File_Name(m_device, file, tmp_new_basename.c_str()); criticalLeave(); free(static_cast<void*>(file->filename)); free(static_cast<void*>(file)); if (rval > 0) { logerr("Could not rename '", oldpath, "' to '", newpath, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -EINVAL; } const_cast<TypeFile*>(file_to_rename)->setName(tmp_new_basename); logmsg("File '", oldpath, "' renamed to '", tmp_new_basename, "'.\n"); return 0; }
static void prune_empty_folders(LIBMTP_mtpdevice_t *device, LIBMTP_file_t *files, LIBMTP_folder_t *folderlist, int do_delete) { if(folderlist==NULL) return; if(folderlist->child == NULL) { int found = 0; LIBMTP_file_t *file; file = files; while (file != NULL) { if(file->parent_id == folderlist->folder_id) { found = 1; break; } file = file->next; } if(found == 0) { printf("empty folder %u (%s)\n",folderlist->folder_id,folderlist->name); if(do_delete) { if (LIBMTP_Delete_Object(device,folderlist->folder_id) != 0) { printf("Couldn't delete folder %u\n",folderlist->folder_id); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } } } } prune_empty_folders(device,files,folderlist->child,do_delete); prune_empty_folders(device,files,folderlist->sibling,do_delete); }
static PyObject * Device_get_filesystem(Device *self, PyObject *args) { PyObject *ans, *errs, *callback; unsigned long storage_id; int ok = 0; ENSURE_DEV(NULL); ENSURE_STORAGE(NULL); if (!PyArg_ParseTuple(args, "kO", &storage_id, &callback)) return NULL; if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "callback is not a callable"); return NULL; } ans = PyList_New(0); errs = PyList_New(0); if (errs == NULL || ans == NULL) { PyErr_NoMemory(); return NULL; } LIBMTP_Clear_Errorstack(self->device); ok = recursive_get_files(self->device, (uint32_t)storage_id, 0xFFFFFFFF, ans, errs, callback, 0); dump_errorstack(self->device, errs); if (!ok) { Py_DECREF(ans); Py_DECREF(errs); return NULL; } return Py_BuildValue("NN", ans, errs); } // }}}
void getfile_function(char * from_path,char * to_path) { int id = parse_path (from_path,files,folders); if (id > 0) { printf("Getting %s to %s\n",from_path,to_path); if (LIBMTP_Get_File_To_File(device, id, to_path, progress, NULL) != 0 ) { printf("\nError getting file from MTP device.\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } } }
static void dump_errorstack(LIBMTP_mtpdevice_t *dev, PyObject *list) { LIBMTP_error_t *stack; PyObject *err; for(stack = LIBMTP_Get_Errorstack(dev); stack != NULL; stack=stack->next) { err = Py_BuildValue("is", stack->errornumber, stack->error_text); if (err == NULL) break; PyList_Append(list, err); Py_DECREF(err); } LIBMTP_Clear_Errorstack(dev); }
int MTPDevice::filePush(const std::string &src, const std::string &dst) { const std::string dst_basename(smtpfs_basename(dst)); const std::string dst_dirname(smtpfs_dirname(dst)); const TypeDir *dir_parent = dirFetchContent(dst_dirname); const TypeFile *file_to_remove = dir_parent ? dir_parent->file(dst_basename) : nullptr; if (dir_parent && file_to_remove) { criticalEnter(); int rval = LIBMTP_Delete_Object(m_device, file_to_remove->id()); criticalLeave(); if (rval != 0) { logerr("Can not upload '", src, "' to '", dst, "'.\n"); return -EINVAL; } } struct stat file_stat; stat(src.c_str(), &file_stat); TypeFile file_to_upload(0, dir_parent->id(), dir_parent->storageid(), dst_basename, static_cast<uint64_t>(file_stat.st_size), 0); LIBMTP_file_t *f = file_to_upload.toLIBMTPFile(); if (file_stat.st_size) logmsg("Started uploading '", dst, "'.\n"); criticalEnter(); int rval = LIBMTP_Send_File_From_File(m_device, src.c_str(), f, nullptr, nullptr); criticalLeave(); if (rval != 0) { logerr("Could not upload file '", src, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); rval = -EINVAL; } else { file_to_upload.setId(f->item_id); file_to_upload.setParent(f->parent_id); file_to_upload.setStorage(f->storage_id); file_to_upload.setName(std::string(f->filename)); file_to_upload.setModificationDate(file_stat.st_mtime); if (file_to_remove) const_cast<TypeDir*>(dir_parent)->replaceFile(*file_to_remove, file_to_upload); else const_cast<TypeDir*>(dir_parent)->addFile(file_to_upload); } free(static_cast<void*>(f->filename)); free(static_cast<void*>(f)); logmsg("File '", dst, (file_stat.st_size ? " uploaded" : " created"), ".\n"); return rval; }
static void report_libmtp_errors (LIBMTP_mtpdevice_t *device, gboolean use_dialog) { LIBMTP_error_t *stack; for (stack = LIBMTP_Get_Errorstack (device); stack != NULL; stack = stack->next) { if (use_dialog) { rb_error_dialog (NULL, _("Media player device error"), "%s", stack->error_text); /* only display one dialog box per error */ use_dialog = FALSE; } else { g_warning ("libmtp error: %s", stack->error_text); } } LIBMTP_Clear_Errorstack (device); }
static void upload_track (RBMtpThread *thread, RBMtpThreadTask *task) { RBMtpUploadCallback cb = (RBMtpUploadCallback) task->callback; LIBMTP_error_t *stack; GError *error = NULL; if (LIBMTP_Send_Track_From_File (thread->device, task->filename, task->track, NULL, NULL)) { stack = LIBMTP_Get_Errorstack (thread->device); rb_debug ("unable to send track: %s", stack->error_text); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_SEND_TRACK, _("Unable to send file to MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); task->track->item_id = 0; /* is this actually an invalid item ID? */ } cb (task->track, error, task->user_data); g_clear_error (&error); }
void Plugin::handleUploadFinished () { auto watcher = dynamic_cast<QFutureWatcher<UploadInfo>*> (sender ()); watcher->deleteLater (); const auto& info = watcher->result (); qDebug () << "send result:" << info.Res_; if (info.Res_) { LIBMTP_Dump_Errorstack (info.Device_); LIBMTP_Clear_Errorstack (info.Device_); } AppendAlbum (info.Device_, info.Track_, info.Info_); LIBMTP_destroy_track_t (info.Track_); emit uploadFinished (info.LocalPath_, QFile::NoError, {}); }
void rb_mtp_thread_report_errors (RBMtpThread *thread, gboolean use_dialog) { LIBMTP_error_t *stack; for (stack = LIBMTP_Get_Errorstack (thread->device); stack != NULL; stack = stack->next) { if (use_dialog) { GDK_THREADS_ENTER (); rb_error_dialog (NULL, _("Media player device error"), "%s", stack->error_text); GDK_THREADS_LEAVE (); /* only display one dialog box per error */ use_dialog = FALSE; } else { g_warning ("libmtp error: %s", stack->error_text); } } LIBMTP_Clear_Errorstack (thread->device); }
int main (int argc, char **argv) { LIBMTP_mtpdevice_t *device; int ret; fprintf(stdout, "libmtp version: " LIBMTP_VERSION_STRING "\n\n"); LIBMTP_Init(); device = LIBMTP_Get_First_Device(); if (device == NULL) { printf("No devices.\n"); return 0; } printf("I will now format your device. This means that\n"); printf("all content (and licenses) will be lost forever.\n"); printf("you will not be able to undo this operation.\n"); printf("Continue? (y/n)\n"); if (prompt() == 0) { // This will just format the first storage. ret = LIBMTP_Format_Storage(device, device->storage); } else { printf("Aborted.\n"); ret = 0; } if ( ret != 0 ) { printf("Failed to format device.\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); LIBMTP_Release_Device(device); return 1; } LIBMTP_Release_Device(device); printf("OK.\n"); return 0; }
static void dump_plinfo(LIBMTP_mtpdevice_t *device, LIBMTP_playlist_t *pl) { uint32_t i; printf("Playlist ID: %d\n", pl->playlist_id); if (pl->name != NULL) printf(" Name: %s\n", pl->name); printf(" Parent ID: %d\n", pl->parent_id); printf(" Tracks:\n"); for (i = 0; i < pl->no_tracks; i++) { LIBMTP_track_t *track; track = LIBMTP_Get_Trackmetadata(device, pl->tracks[i]); if (track != NULL) { printf(" %u: %s - %s\n", pl->tracks[i], track->artist, track->title); LIBMTP_destroy_track_t(track); } else { printf(" %u: INVALID TRACK REFERENCE!\n", pl->tracks[i]); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } } }
int main (int argc, char **argv) { int opt; extern int optind; extern char *optarg; LIBMTP_mtpdevice_t *device = NULL; int fd; uint32_t id = 0; uint64_t filesize; uint8_t *imagedata = NULL; char *path = NULL; char *rest; struct stat statbuff; int ret; fprintf(stdout, "libmtp version: " LIBMTP_VERSION_STRING "\n\n"); while ( (opt = getopt(argc, argv, "hi:")) != -1 ) { switch (opt) { case 'h': usage(); case 'i': id = strtoul(optarg, &rest, 0); break; default: usage(); } } argc -= optind; argv += optind; if ( argc != 1 ) { printf("You need to pass a filename.\n"); usage(); } path = argv[0]; if ( stat(path, &statbuff) == -1 ) { fprintf(stderr, "%s: ", path); perror("stat"); exit(1); } filesize = (uint64_t) statbuff.st_size; imagedata = malloc(filesize * sizeof(uint16_t)); #ifdef __WIN32__ if ( (fd = open(path, O_RDONLY|O_BINARY) == -1) ) { #else if ( (fd = open(path, O_RDONLY)) == -1) { #endif printf("Couldn't open image file %s (%s)\n",path,strerror(errno)); return 1; } else { read(fd, imagedata, filesize); close(fd); } LIBMTP_Init(); device = LIBMTP_Get_First_Device(); if (device == NULL) { printf("No devices.\n"); return 0; } LIBMTP_filesampledata_t *thumb = LIBMTP_new_filesampledata_t(); int i; thumb->data = malloc(sizeof(uint16_t) * filesize); for (i = 0; i < filesize; i++) { thumb->data[i] = imagedata[i]; } thumb->size = filesize; thumb->filetype = LIBMTP_FILETYPE_JPEG; ret = LIBMTP_Send_Representative_Sample(device,id,thumb); if (ret != 0) { printf("Couldn't send thumbnail\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } free(imagedata); LIBMTP_destroy_filesampledata_t(thumb); LIBMTP_Release_Device(device); printf("OK.\n"); return 0; }
int main (int argc, char **argv) { int opt; extern int optind; extern char *optarg; LIBMTP_mtpdevice_t *device = NULL; int idcount = 0; uint32_t *ids = NULL; uint32_t *tmp = NULL; char *playlistname = NULL; char *rest; uint32_t storageid = 0; uint32_t parentid = 0; fprintf(stdout, "libmtp version: " LIBMTP_VERSION_STRING "\n\n"); while ( (opt = getopt(argc, argv, "hn:i:s:p:")) != -1 ) { switch (opt) { case 'h': usage(); case 'i': idcount++; if ((tmp = realloc(ids, sizeof(uint32_t) * (idcount))) == NULL) { printf("realloc failed\n"); return 1; } ids = tmp; ids[(idcount-1)] = strtoul(optarg, &rest, 0); break; case 'n': playlistname = strdup(optarg); break; case 's': storageid = (uint32_t) strtoul(optarg, NULL, 0); break; case 'p': parentid = (uint32_t) strtoul(optarg, NULL, 0); break; default: usage(); } } argc -= optind; argv += optind; if ( playlistname == NULL) { printf("You need to supply a playlist name.\n"); usage(); } if (idcount == 0) { printf("You need to supply one or more track IDs\n"); usage(); } LIBMTP_Init(); device = LIBMTP_Get_First_Device(); if (device == NULL) { printf("No devices.\n"); return 0; } LIBMTP_playlist_t *playlist = LIBMTP_new_playlist_t(); playlist->name = playlistname; playlist->no_tracks = idcount; playlist->tracks = ids; playlist->parent_id = parentid; playlist->storage_id = storageid; int ret = LIBMTP_Create_New_Playlist(device,playlist); if (ret != 0) { printf("Couldn't create playlist object\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } else { printf("Created new playlist: %u\n", playlist->playlist_id); } LIBMTP_Release_Device(device); printf("OK.\n"); return 0; }
static void download_track (RBMtpThread *thread, RBMtpThreadTask *task) { LIBMTP_file_t *fileinfo; LIBMTP_error_t *stack; GError *error = NULL; GFile *dir; RBMtpDownloadCallback cb = (RBMtpDownloadCallback) task->callback; /* first, check there's enough space to copy it */ fileinfo = LIBMTP_Get_Filemetadata (thread->device, task->track_id); if (fileinfo == NULL) { stack = LIBMTP_Get_Errorstack (thread->device); rb_debug ("unable to get track metadata for %u: %s", task->track_id, stack->error_text); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } if (task->filename[0] == '\0') { dir = g_file_new_for_path (g_get_tmp_dir ()); } else { GFile *file = g_file_new_for_path (task->filename); dir = g_file_get_parent (file); g_object_unref (file); } rb_debug ("checking for %" G_GINT64_FORMAT " bytes available", fileinfo->filesize); if (rb_check_dir_has_space (dir, fileinfo->filesize) == FALSE) { char *dpath = g_file_get_path (dir); rb_debug ("not enough space in %s", dpath); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_NO_SPACE, _("Not enough space in %s"), dpath); g_free (dpath); } LIBMTP_destroy_file_t (fileinfo); g_object_unref (dir); if (error != NULL) { rb_debug ("bailing out due to error: %s", error->message); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } if (task->filename[0] == '\0') { /* download to a temporary file */ int fd; GError *tmperror = NULL; g_free (task->filename); fd = g_file_open_tmp ("rb-mtp-temp-XXXXXX", &task->filename, &tmperror); if (fd == -1) { rb_debug ("unable to open temporary file: %s", tmperror->message); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_TEMPFILE, _("Unable to open temporary file: %s"), tmperror->message); g_error_free (tmperror); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } else { rb_debug ("downloading track %u to file descriptor %d", task->track_id, fd); if (LIBMTP_Get_Track_To_File_Descriptor (thread->device, task->track_id, fd, NULL, NULL)) { stack = LIBMTP_Get_Errorstack (thread->device); rb_debug ("unable to retrieve track %u: %s", task->track_id, stack->error_text); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); close (fd); remove (task->filename); return; } rb_debug ("done downloading track"); close (fd); } } else { if (LIBMTP_Get_Track_To_File (thread->device, task->track_id, task->filename, NULL, NULL)) { stack = LIBMTP_Get_Errorstack (thread->device); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } } cb (task->track_id, task->filename, NULL, task->user_data); }
int main(int argc, char **argv) { int mainret = 0; if (argc < 2) { fprintf(stderr, "usage: %s [-d] mountpoint\n", argv[0]); exit(1); } char *mount_point = argv[1]; argc -= 1; argv += 1; // LIBMTP_Set_Debug(LIBMTP_DEBUG_PTP | LIBMTP_DEBUG_DATA); LIBMTP_Init(); LIBMTP_error_number_t mtperr; LIBMTP_raw_device_t *rawdevs; int nrawdev; mtperr = LIBMTP_Detect_Raw_Devices(&rawdevs, &nrawdev); switch (mtperr) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: fprintf(stderr, "no raw devices\n"); exit(0); case LIBMTP_ERROR_CONNECTING: fprintf(stderr, "ERROR connecting\n"); exit(1); case LIBMTP_ERROR_MEMORY_ALLOCATION: fprintf(stderr, "ERROR memory allocation\n"); exit(1); case LIBMTP_ERROR_NONE: break; default: fprintf(stderr, "ERROR unknown\n"); exit(1); } printf("%d raw devices:\n", nrawdev); int i; for (i = 0; i < nrawdev; ++i) { printf(" device #%d: %s: %s (%04X:%04X) @ bus %d, dev %d\n", i, rawdevs[i].device_entry.vendor, rawdevs[i].device_entry.product, rawdevs[i].device_entry.vendor_id, rawdevs[i].device_entry.product_id, rawdevs[i].bus_location, rawdevs[i].devnum); } mtpfuse_t ctx; memset(&ctx, 0, sizeof(ctx)); printf("opening raw device #0...\n"); ctx.dev = LIBMTP_Open_Raw_Device_Uncached(&rawdevs[0]); if (!ctx.dev) { fprintf(stderr, "ERROR opening raw device #0\n"); exit(1); } LIBMTP_Dump_Errorstack(ctx.dev); LIBMTP_Clear_Errorstack(ctx.dev); char *name = LIBMTP_Get_Friendlyname(ctx.dev); printf("opened raw device %s.\n", name); int ret = LIBMTP_Get_Storage(ctx.dev, LIBMTP_STORAGE_SORTBY_NOTSORTED); if (ret != 0) { fprintf(stderr, "ERROR get %s's storage:\n", name); LIBMTP_Dump_Errorstack(ctx.dev); mainret = 1; goto done; } printf("device's storage:\n"); LIBMTP_devicestorage_t *storage; for (storage = ctx.dev->storage, i = 0; storage; storage = storage->next, ++i) { printf(" storage #%d: %d - %s\n", i, storage->id, storage->StorageDescription); } if (i <= 0) { fprintf(stderr, "there is no storage that is usable.\n"); mainret = 1; goto done; } mainret = fuse_main(argc, argv, &mtpfuse_ops, &ctx); done: LIBMTP_Release_Device(ctx.dev); return mainret; }
int main (int argc, char **argv) { LIBMTP_raw_device_t * rawdevices; int numrawdevices; LIBMTP_error_number_t err; int i; int opt; extern int optind; extern char *optarg; while ((opt = getopt(argc, argv, "d")) != -1 ) { switch (opt) { case 'd': LIBMTP_Set_Debug(LIBMTP_DEBUG_PTP | LIBMTP_DEBUG_DATA); break; } } argc -= optind; argv += optind; LIBMTP_Init(); err = LIBMTP_Detect_Raw_Devices(&rawdevices, &numrawdevices); switch(err) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: fprintf(stdout, " No raw devices found.\n"); return 0; case LIBMTP_ERROR_CONNECTING: fprintf(stderr, "Detect: There has been an error connecting. Exiting\n"); return 1; case LIBMTP_ERROR_MEMORY_ALLOCATION: fprintf(stderr, "Detect: Encountered a Memory Allocation Error. Exiting\n"); return 1; case LIBMTP_ERROR_NONE: break; case LIBMTP_ERROR_GENERAL: default: fprintf(stderr, "Unknown connection error.\n"); return 1; } /* Iterate over connected MTP devices */ fprintf(stdout, "Attempting to connect device(s)\n"); for (i = 0; i < numrawdevices; i++) { LIBMTP_mtpdevice_t *device; LIBMTP_devicestorage_t *storage; char *friendlyname; int ret; device = LIBMTP_Open_Raw_Device_Uncached(&rawdevices[i]); if (device == NULL) { fprintf(stderr, "Unable to open raw device %d\n", i); continue; } LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); friendlyname = LIBMTP_Get_Friendlyname(device); if (friendlyname == NULL) { printf("Device: (NULL)\n"); } else { printf("Device: %s\n", friendlyname); free(friendlyname); } /* Get all storages for this device */ ret = LIBMTP_Get_Storage(device, LIBMTP_STORAGE_SORTBY_NOTSORTED); if (ret != 0) { perror("LIBMTP_Get_Storage()"); goto bailout; } /* Loop over storages */ for (storage = device->storage; storage != 0; storage = storage->next) { fprintf(stdout, "Storage: %s\n", storage->StorageDescription); recursive_file_tree(device, storage, 0, 0); } bailout: LIBMTP_Release_Device(device); } /* End For Loop */ free(rawdevices); printf("OK.\n"); return 0; }
int main (int argc, char **argv) { LIBMTP_mtpdevice_t *device_list, *iter; LIBMTP_file_t *files; fprintf(stdout, "libmtp version: " LIBMTP_VERSION_STRING "\n\n"); LIBMTP_Init(); switch(LIBMTP_Get_Connected_Devices(&device_list)) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: fprintf(stdout, "mtp-files: No Devices have been found\n"); return 0; case LIBMTP_ERROR_CONNECTING: fprintf(stderr, "mtp-files: There has been an error connecting. Exit\n"); return 1; case LIBMTP_ERROR_MEMORY_ALLOCATION: fprintf(stderr, "mtp-files: Memory Allocation Error. Exit\n"); return 1; /* Unknown general errors - This should never execute */ case LIBMTP_ERROR_GENERAL: default: fprintf(stderr, "mtp-files: Unknown error, please report " "this to the libmtp developers\n"); return 1; /* Successfully connected at least one device, so continue */ case LIBMTP_ERROR_NONE: fprintf(stdout, "mtp-files: Successfully connected\n"); fflush(stdout); } /* iterate through connected MTP devices */ for(iter = device_list; iter != NULL; iter = iter->next) { char *friendlyname; /* Echo the friendly name so we know which device we are working with */ friendlyname = LIBMTP_Get_Friendlyname(iter); if (friendlyname == NULL) { printf("Listing File Information on Device with name: (NULL)\n"); } else { printf("Listing File Information on Device with name: %s\n", friendlyname); free(friendlyname); } /* Get track listing. */ files = LIBMTP_Get_Filelisting_With_Callback(iter, NULL, NULL); if (files == NULL) { printf("No files.\n"); LIBMTP_Dump_Errorstack(iter); LIBMTP_Clear_Errorstack(iter); } else { LIBMTP_file_t *file, *tmp; file = files; while (file != NULL) { dump_fileinfo(file); tmp = file; file = file->next; LIBMTP_destroy_file_t(tmp); } } } LIBMTP_Release_Device_List(device_list); printf("OK.\n"); exit (0); }
static int add_track_to_album(LIBMTP_album_t *albuminfo, LIBMTP_track_t *trackmeta) { LIBMTP_album_t *album; LIBMTP_album_t *album_orig; LIBMTP_album_t *found_album = NULL; int ret; /* Look for the album */ album = LIBMTP_Get_Album_List(device); album_orig = album; while(album != NULL) { if ((album->name != NULL && album->artist != NULL && !strcmp(album->name, albuminfo->name) && !strcmp(album->artist, albuminfo->artist)) || (album->name != NULL && album->composer != NULL && !strcmp(album->name, albuminfo->name) && !strcmp(album->composer, albuminfo->composer))) { /* Disconnect this album for later use */ found_album = album; album = album->next; found_album->next = NULL; } else { album = album->next; } } if (found_album == NULL) { printf("Could not find Album. Retrying with only Album name\n"); album = album_orig; while(album != NULL) { if ((album->name != NULL) && !strcmp(album->name, albuminfo->name) ){ /* Disconnect this album for later use */ found_album = album; album = album->next; found_album->next = NULL; } else { album = album->next; } } } if (found_album != NULL) { uint32_t *tracks; tracks = (uint32_t *)malloc((found_album->no_tracks+1) * sizeof(uint32_t)); printf("Album \"%s\" found: updating...\n", found_album->name); if (!tracks) { printf("failed malloc in add_track_to_album()\n"); return 1; } found_album->no_tracks++; if (found_album->tracks != NULL) { memcpy(tracks, found_album->tracks, found_album->no_tracks * sizeof(uint32_t)); free(found_album->tracks); } tracks[found_album->no_tracks-1] = trackmeta->item_id; found_album->tracks = tracks; ret = LIBMTP_Update_Album(device, found_album); } else { uint32_t *trackid; trackid = (uint32_t *)malloc(sizeof(uint32_t)); *trackid = trackmeta->item_id; albuminfo->tracks = trackid; albuminfo->no_tracks = 1; albuminfo->storage_id = trackmeta->storage_id; printf("Album doesn't exist: creating...\n"); ret = LIBMTP_Create_New_Album(device, albuminfo); /* albuminfo will be destroyed later by caller */ } /* Delete the earlier retrieved Album list */ album=album_orig; while(album!=NULL){ LIBMTP_album_t *tmp; tmp = album; album = album->next; LIBMTP_destroy_album_t(tmp); } if (ret != 0) { printf("Error creating or updating album.\n"); printf("(This could be due to that your device does not support albums.)\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } else { printf("success!\n"); } return ret; }
int main (int argc, char **argv) { LIBMTP_raw_device_t * rawdevices; int numrawdevices; LIBMTP_error_number_t err; int i; int opt; extern int optind; extern char *optarg; while ((opt = getopt(argc, argv, "d")) != -1 ) { switch (opt) { case 'd': LIBMTP_Set_Debug(LIBMTP_DEBUG_PTP | LIBMTP_DEBUG_DATA); break; } } argc -= optind; argv += optind; LIBMTP_Init(); fprintf(stdout, "libmtp version: " LIBMTP_VERSION_STRING "\n\n"); fprintf(stdout, "Listing raw device(s)\n"); err = LIBMTP_Detect_Raw_Devices(&rawdevices, &numrawdevices); switch(err) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: fprintf(stdout, " No raw devices found.\n"); return 0; case LIBMTP_ERROR_CONNECTING: fprintf(stderr, "Detect: There has been an error connecting. Exiting\n"); return 1; case LIBMTP_ERROR_MEMORY_ALLOCATION: fprintf(stderr, "Detect: Encountered a Memory Allocation Error. Exiting\n"); return 1; case LIBMTP_ERROR_NONE: { int i; fprintf(stdout, " Found %d device(s):\n", numrawdevices); for (i = 0; i < numrawdevices; i++) { if (rawdevices[i].device_entry.vendor != NULL || rawdevices[i].device_entry.product != NULL) { fprintf(stdout, " %s: %s (%04x:%04x) @ bus %d, dev %d\n", rawdevices[i].device_entry.vendor, rawdevices[i].device_entry.product, rawdevices[i].device_entry.vendor_id, rawdevices[i].device_entry.product_id, rawdevices[i].bus_location, rawdevices[i].devnum); } else { fprintf(stdout, " %04x:%04x @ bus %d, dev %d\n", rawdevices[i].device_entry.vendor_id, rawdevices[i].device_entry.product_id, rawdevices[i].bus_location, rawdevices[i].devnum); } } } break; case LIBMTP_ERROR_GENERAL: default: fprintf(stderr, "Unknown connection error.\n"); return 1; } /* Iterate over connected MTP devices */ fprintf(stdout, "Attempting to connect device(s)\n"); for (i = 0; i < numrawdevices; i++) { LIBMTP_mtpdevice_t *device; LIBMTP_devicestorage_t *storage; char *friendlyname; char *syncpartner; char *sectime; char *devcert; uint16_t *filetypes; uint16_t filetypes_len; uint8_t maxbattlevel; uint8_t currbattlevel; int ret; device = LIBMTP_Open_Raw_Device_Uncached(&rawdevices[i]); if (device == NULL) { fprintf(stderr, "Unable to open raw device %d\n", i); continue; } LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); LIBMTP_Dump_Device_Info(device); printf("MTP-specific device properties:\n"); // The friendly name friendlyname = LIBMTP_Get_Friendlyname(device); if (friendlyname == NULL) { fprintf(stdout, " Friendly name: (NULL)\n"); } else { fprintf(stdout, " Friendly name: %s\n", friendlyname); free(friendlyname); } syncpartner = LIBMTP_Get_Syncpartner(device); if (syncpartner == NULL) { fprintf(stdout, " Synchronization partner: (NULL)\n"); } else { fprintf(stdout, " Synchronization partner: %s\n", syncpartner); free(syncpartner); } // Some battery info ret = LIBMTP_Get_Batterylevel(device, &maxbattlevel, &currbattlevel); if (ret == 0) { fprintf(stdout, " Battery level %d of %d (%d%%)\n",currbattlevel, maxbattlevel, (int) ((float) currbattlevel/ (float) maxbattlevel * 100.0)); } else { // Silently ignore. Some devices does not support getting the // battery level. LIBMTP_Clear_Errorstack(device); } ret = LIBMTP_Get_Supported_Filetypes(device, &filetypes, &filetypes_len); if (ret == 0) { uint16_t i; printf("libmtp supported (playable) filetypes:\n"); for (i = 0; i < filetypes_len; i++) { fprintf(stdout, " %s\n", LIBMTP_Get_Filetype_Description(filetypes[i])); } } else { LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } // Secure time XML fragment ret = LIBMTP_Get_Secure_Time(device, §ime); if (ret == 0 && sectime != NULL) { fprintf(stdout, "\nSecure Time:\n%s\n", sectime); free(sectime); } else { // Silently ignore - there may be devices not supporting secure time. LIBMTP_Clear_Errorstack(device); } // Device certificate XML fragment if (rawdevices[i].device_entry.vendor_id == 0x041e) { /* * This code is currently disabled except for vendors we * know does support it: all devices say that * they support getting a device certificate but a lot of * them obviously doesn't, instead they crash when you try * to obtain it. */ ret = LIBMTP_Get_Device_Certificate(device, &devcert); if (ret == 0 && devcert != NULL) { fprintf(stdout, "\nDevice Certificate:\n%s\n", devcert); free(devcert); } else { fprintf(stdout, "Unable to acquire device certificate, perhaps this device " "does not support this\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } } /* Try to get Media player device info XML file... */ /* Loop over storages */ for (storage = device->storage; storage != 0; storage = storage->next) { LIBMTP_file_t *files; /* Get file listing for the root directory, no other dirs */ files = LIBMTP_Get_Files_And_Folders(device, storage->id, 0); if (files != NULL) { LIBMTP_file_t *file, *tmp; file = files; while (file != NULL) { if (!strcmp(file->filename, "WMPInfo.xml") || !strcmp(file->filename, "WMPinfo.xml") || !strcmp(file->filename, "default-capabilities.xml")) { if (file->item_id != 0) { /* Dump this file */ FILE *xmltmp = tmpfile(); int tmpfiledescriptor = fileno(xmltmp); if (tmpfiledescriptor != -1) { int ret = LIBMTP_Get_Track_To_File_Descriptor(device, file->item_id, tmpfiledescriptor, NULL, NULL); if (ret == 0) { uint8_t *buf = NULL; uint32_t readbytes; buf = malloc(XML_BUFSIZE); if (buf == NULL) { printf("Could not allocate %08x bytes...\n", XML_BUFSIZE); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); free(rawdevices); return 1; } lseek(tmpfiledescriptor, 0, SEEK_SET); readbytes = read(tmpfiledescriptor, (void*) buf, XML_BUFSIZE); if (readbytes >= 2 && readbytes < XML_BUFSIZE) { fprintf(stdout, "\n%s file contents:\n", file->filename); dump_xml_fragment(buf, readbytes); } else { perror("Unable to read file"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } free(buf); } else { LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } fclose(xmltmp); } } } tmp = file; file = file->next; LIBMTP_destroy_file_t(tmp); } } } LIBMTP_Release_Device(device); } /* End For Loop */ free(rawdevices); printf("OK.\n"); return 0; }
int sendtrack_function(char * from_path, char * to_path, char *partist, char *palbumartist, char *ptitle, char *pgenre, char *palbum, char *pcomposer, uint16_t tracknum, uint16_t length, uint16_t year, uint32_t storageid, uint16_t quiet) { char *filename, *parent; char artist[80], albumartist[80], title[80], genre[80], album[80], composer[80]; char num[80]; uint64_t filesize; uint32_t parent_id = 0; struct stat sb; LIBMTP_track_t *trackmeta; LIBMTP_album_t *albuminfo; int ret; printf("Sending track %s to %s\n", from_path, to_path); trackmeta = LIBMTP_new_track_t(); albuminfo = LIBMTP_new_album_t(); parent = dirname(strdup(to_path)); filename = basename(strdup(to_path)); parent_id = parse_path (parent,files,folders); if (parent_id == -1) { printf("Parent folder could not be found, skipping\n"); return 1; } if (stat(from_path, &sb) == -1) { fprintf(stderr, "%s: ", from_path); perror("stat"); return 1; } if (!S_ISREG(sb.st_mode)) return 0; filesize = sb.st_size; trackmeta->filetype = find_filetype (from_path); if (!LIBMTP_FILETYPE_IS_TRACK(trackmeta->filetype)) { printf("Not a valid track codec: \"%s\"\n", LIBMTP_Get_Filetype_Description(trackmeta->filetype)); return 1; } if ((ptitle == NULL) && (quiet == 0)) { if ( (ptitle = prompt("Title", title, 80, 0)) != NULL ) if (!strlen(ptitle)) ptitle = NULL; } if ((palbum == NULL) && (quiet == 0)) { if ( (palbum = prompt("Album", album, 80, 0)) != NULL ) if (!strlen(palbum)) palbum = NULL; } if ((palbumartist == NULL) && (quiet == 0)) { if ( (palbumartist = prompt("Album artist", albumartist, 80, 0)) != NULL ) if (!strlen(palbumartist)) palbumartist = NULL; } if ((partist == NULL) && (quiet == 0)) { if ( (partist = prompt("Artist", artist, 80, 0)) != NULL ) if (!strlen(partist)) partist = NULL; } if ((pcomposer == NULL) && (quiet == 0)) { if ( (pcomposer = prompt("Writer or Composer", composer, 80, 0)) != NULL ) if (!strlen(pcomposer)) pcomposer = NULL; } if ((pgenre == NULL) && (quiet == 0)) { if ( (pgenre = prompt("Genre", genre, 80, 0)) != NULL ) if (!strlen(pgenre)) pgenre = NULL; } if ((tracknum == 0) && (quiet == 0)) { char *pnum; if ( (pnum = prompt("Track number", num, 80, 0)) == NULL ) tracknum = 0; else tracknum = strtoul(pnum, 0, 10); } if ((year == 0) && (quiet == 0)) { char *pnum; if ( (pnum = prompt("Year", num, 80, 0)) == NULL ) year = 0; else year = strtoul(pnum, 0, 10); } if ((length == 0) && (quiet == 0)) { char *pnum; if ( (pnum = prompt("Length", num, 80, 0)) == NULL ) length = 0; else length = strtoul(pnum, 0, 10); } printf("Sending track:\n"); printf("Codec: %s\n", LIBMTP_Get_Filetype_Description(trackmeta->filetype)); if (ptitle) { printf("Title: %s\n", ptitle); trackmeta->title = strdup(ptitle); } if (palbum) { printf("Album: %s\n", palbum); trackmeta->album = strdup(palbum); albuminfo->name = strdup(palbum); } if (palbumartist) { printf("Album artist: %s\n", palbumartist); albuminfo->artist = strdup(palbumartist); } if (partist) { printf("Artist: %s\n", partist); trackmeta->artist = strdup(partist); if (palbumartist == NULL) albuminfo->artist = strdup(partist); } if (pcomposer) { printf("Writer or Composer: %s\n", pcomposer); trackmeta->composer = strdup(pcomposer); albuminfo->composer = strdup(pcomposer); } if (pgenre) { printf("Genre: %s\n", pgenre); trackmeta->genre = strdup(pgenre); albuminfo->genre = strdup(pgenre); } if (year > 0) { char tmp[80]; printf("Year: %d\n", year); snprintf(tmp, sizeof(tmp)-1, "%4d0101T0000.0", year); tmp[sizeof(tmp)-1] = '\0'; trackmeta->date = strdup(tmp); } if (tracknum > 0) { printf("Track no: %d\n", tracknum); trackmeta->tracknumber = tracknum; } if (length > 0) { printf("Length: %d\n", length); // Multiply by 1000 since this is in milliseconds trackmeta->duration = length * 1000; } // We should always have this if (filename != NULL) { trackmeta->filename = strdup(filename); } trackmeta->filesize = filesize; trackmeta->parent_id = parent_id; { int rc; char *desc = NULL; LIBMTP_devicestorage_t *pds = NULL; if (0 != (rc=LIBMTP_Get_Storage(device, LIBMTP_STORAGE_SORTBY_NOTSORTED))) { perror("LIBMTP_Get_Storage()"); exit(-1); } for (pds = device->storage; pds != NULL; pds = pds->next) { if (pds->id == storageid) { desc = strdup(pds->StorageDescription); break; } } if (NULL != desc) { printf("Storage ID: %s (%u)\n", desc, storageid); free(desc); } else printf("Storage ID: %u\n", storageid); trackmeta->storage_id = storageid; } printf("Sending track...\n"); ret = LIBMTP_Send_Track_From_File(device, from_path, trackmeta, progress, NULL); printf("\n"); if (ret != 0) { printf("Error sending track.\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); ret = 1; } else { printf("New track ID: %d\n", trackmeta->item_id); } /* Add here add to album call */ if (palbum) ret = add_track_to_album(albuminfo, trackmeta); LIBMTP_destroy_album_t(albuminfo); LIBMTP_destroy_track_t(trackmeta); return ret; }
int MTPDevice::rename(const std::string &oldpath, const std::string &newpath) { #ifndef SMTPFS_MOVE_BY_SET_OBJECT_PROPERTY const std::string tmp_old_basename(smtpfs_basename(oldpath)); const std::string tmp_old_dirname(smtpfs_dirname(oldpath)); const std::string tmp_new_dirname(smtpfs_dirname(newpath)); if (tmp_old_dirname != tmp_new_dirname) return -EINVAL; const TypeDir *dir_parent = dirFetchContent(tmp_old_dirname); if (!dir_parent || dir_parent->id() == 0) return -EINVAL; const TypeDir *dir_to_rename = dir_parent->dir(tmp_old_basename); if (dir_to_rename) return dirRename(oldpath, newpath); else return fileRename(oldpath, newpath); #else const std::string tmp_old_basename(smtpfs_basename(oldpath)); const std::string tmp_old_dirname(smtpfs_dirname(oldpath)); const std::string tmp_new_basename(smtpfs_basename(newpath)); const std::string tmp_new_dirname(smtpfs_dirname(newpath)); const TypeDir *dir_old_parent = dirFetchContent(tmp_old_dirname); const TypeDir *dir_new_parent = dirFetchContent(tmp_new_dirname); const TypeDir *dir_to_rename = dir_old_parent ? dir_old_parent->dir(tmp_old_basename) : nullptr; const TypeFile *file_to_rename = dir_old_parent ? dir_old_parent->file(tmp_old_basename) : nullptr; logdebug("dir_to_rename: ", dir_to_rename, "\n"); logdebug("file_to_rename: ", file_to_rename, "\n"); if (!dir_old_parent || !dir_new_parent || dir_old_parent->id() == 0) return -EINVAL; const TypeBasic *object_to_rename = dir_to_rename ? static_cast<const TypeBasic*>(dir_to_rename) : static_cast<const TypeBasic*>(file_to_rename); logdebug("object_to_rename: ", object_to_rename, "\n"); logdebug("object_to_rename->id(): ", object_to_rename->id(), "\n"); if (!object_to_rename) { logerr("No such file or directory to rename/move!\n"); return -ENOENT; } if (tmp_old_dirname != tmp_new_dirname) { criticalEnter(); int rval = LIBMTP_Set_Object_u32(m_device, object_to_rename->id(), LIBMTP_PROPERTY_ParentObject, dir_new_parent->id()); criticalLeave(); if (rval != 0) { logerr("Could not move '", oldpath, "' to '", newpath, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -EINVAL; } const_cast<TypeBasic*>(object_to_rename)->setParent(dir_new_parent->id()); } if (tmp_old_basename != tmp_new_basename) { criticalEnter(); int rval = LIBMTP_Set_Object_String(m_device, object_to_rename->id(), LIBMTP_PROPERTY_Name, tmp_new_basename.c_str()); criticalLeave(); if (rval != 0) { logerr("Could not rename '", oldpath, "' to '", newpath, "'.\n"); LIBMTP_Dump_Errorstack(m_device); LIBMTP_Clear_Errorstack(m_device); return -EINVAL; } } return 0; #endif }
int main (int argc, char **argv) { LIBMTP_raw_device_t *rawdevices; int numrawdevices; int i; LIBMTP_Init(); printf("Attempting to connect device(s)\n"); switch (LIBMTP_Detect_Raw_Devices(&rawdevices, &numrawdevices)) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: printf("mtp-folders: no devices found\n"); return 0; case LIBMTP_ERROR_CONNECTING: fprintf(stderr, "mtp-folders: There has been an error connecting. Exit\n"); return 1; case LIBMTP_ERROR_MEMORY_ALLOCATION: fprintf(stderr, "mtp-folders: Memory Allocation Error. Exit\n"); return 1; /* Unknown general errors - This should never execute */ case LIBMTP_ERROR_GENERAL: default: fprintf(stderr, "mtp-folders: Unknown error, please report " "this to the libmtp developers\n"); return 1; /* Successfully connected at least one device, so continue */ case LIBMTP_ERROR_NONE: printf("mtp-folders: Successfully connected\n"); } /* iterate through connected MTP devices */ for (i = 0; i < numrawdevices; i++) { LIBMTP_mtpdevice_t *device; LIBMTP_devicestorage_t *storage; char *friendlyname; int ret; device = LIBMTP_Open_Raw_Device(&rawdevices[i]); if (device == NULL) { fprintf(stderr, "Unable to open raw device %d\n", i); continue; } /* Echo the friendly name so we know which device we are working with */ friendlyname = LIBMTP_Get_Friendlyname(device); if (friendlyname == NULL) { printf("Friendly name: (NULL)\n"); } else { printf("Friendly name: %s\n", friendlyname); free(friendlyname); } LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); /* Get all storages for this device */ ret = LIBMTP_Get_Storage(device, LIBMTP_STORAGE_SORTBY_NOTSORTED); if (ret != 0) { perror("LIBMTP_Get_Storage()\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); continue; } /* Loop over storages, dump folder for each one */ for (storage = device->storage; storage != 0; storage = storage->next) { LIBMTP_folder_t *folders; printf("Storage: %s\n", storage->StorageDescription); folders = LIBMTP_Get_Folder_List_For_Storage(device, storage->id); if (folders == NULL) { fprintf(stdout, "No folders found\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } else { dump_folder_list(folders,0); } LIBMTP_destroy_folder_t(folders); } LIBMTP_Release_Device(device); } free(rawdevices); printf("OK.\n"); return 0; }
void Plugin::AppendAlbum (LIBMTP_mtpdevice_t *device, LIBMTP_track_t *track, const UnmountableFileInfo& info) { auto albuminfo = LIBMTP_new_album_t (); albuminfo->artist = strdup (info.Artist_.toUtf8 ().constData ()); albuminfo->name = strdup (info.Album_.toUtf8 ().constData ()); albuminfo->genre = strdup (info.Genres_.join ("; ").toUtf8 ().constData ()); auto album = LIBMTP_Get_Album_List (device); auto albumOrig = album; decltype (album) foundAlbum = nullptr, resultingAlgum = nullptr; while (album) { if (album->name && (album->artist || album->composer) && QString::fromUtf8 (album->name) == info.Album_ && (QString::fromUtf8 (album->artist) == info.Artist_ || QString::fromUtf8 (album->composer) == info.Artist_)) { foundAlbum = album; album = album->next; foundAlbum->next = nullptr; } else album = album->next; } if (foundAlbum) { auto tracks = static_cast<uint32_t*> (malloc ((foundAlbum->no_tracks + 1) * sizeof (uint32_t))); ++foundAlbum->no_tracks; if (foundAlbum->tracks) { memcpy (tracks, foundAlbum->tracks, foundAlbum->no_tracks * sizeof (uint32_t)); free (foundAlbum->tracks); } tracks [foundAlbum->no_tracks - 1] = track->item_id; foundAlbum->tracks = tracks; if (LIBMTP_Update_Album (device, foundAlbum)) { LIBMTP_Dump_Errorstack (device); LIBMTP_Clear_Errorstack (device); } resultingAlgum = foundAlbum; } else { auto trackId = static_cast<uint32_t*> (malloc (sizeof (uint32_t))); *trackId = track->item_id; albuminfo->tracks = trackId; albuminfo->no_tracks = 1; albuminfo->storage_id = track->storage_id; if (LIBMTP_Create_New_Album (device, albuminfo)) { LIBMTP_Dump_Errorstack (device); LIBMTP_Clear_Errorstack (device); } resultingAlgum = albuminfo; } SetAlbumArt (device, resultingAlgum, info.AlbumArtPath_); while (albumOrig) { auto tmp = albumOrig; albumOrig = albumOrig->next; LIBMTP_destroy_album_t (tmp); } LIBMTP_destroy_album_t (albuminfo); }