Add LIBMTP_Get_Children() to read the list of raw IDs of a folder.

src/libmtp.c

 /**
  * \file libmtp.c
  *
  * Copyright (C) 2005-2011 Linus Walleij <triad@df.lth.se>
  * Copyright (C) 2005-2008 Richard A. Low <richard@wentnet.com>
  * Copyright (C) 2007 Ted Bullock <tbullock@canada.com>
  * Copyright (C) 2007 Tero Saarni <tero.saarni@gmail.com>
  * Copyright (C) 2008 Florent Mertens <flomertens@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 4397 matching lines @@
     }
   }
 
   free(currentHandles.Handler);
 
   // Return a pointer to the original first file
   // in the big list.
   return retfiles;
 }
 
+/**
+ * This function retrieves the list of ids of files and folders in a certain
+ * folder with id parent on a certain storage on a certain device.
+ * The device used with this operations must have been opened with
+ * LIBMTP_Open_Raw_Device_Uncached() or it will fail.
+ *
+ * NOTE: the request will always perform I/O with the device.
+ * @param device a pointer to the MTP device to report info from.
+ * @param storage a storage on the device to report info from. If
+ *        0 is passed in, the files for the given parent will be
+ *        searched across all available storages.
+ * @param parent the parent folder id.
+ * @param out the pointer where the array of ids is returned. It is
+ *        set only when the returned value > 0. The caller takes the
+ *        ownership of the array and has to free() it.
+ * @return the length of the returned array or -1 in case of failure.
+ */
+
+int LIBMTP_Get_Children(LIBMTP_mtpdevice_t *device,
+                        uint32_t const storage,
+                        uint32_t const parent,
+                        uint32_t **out)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
+  LIBMTP_file_t *retfiles = NULL;
+  LIBMTP_file_t *curfile = NULL;
+  PTPObjectHandles currentHandles;
+  uint32_t storageid;
+  uint16_t ret;
+  int i = 0;
+
+  if (device->cached) {
+    // This function is only supposed to be used by devices
+    // opened as uncached!
+    LIBMTP_ERROR("tried to use %s on a cached device!\n", __func__);
+    return -1;
+  }
+
+  if (FLAG_BROKEN_GET_OBJECT_PROPVAL(ptp_usb)) {
+    // These devices cannot handle the commands needed for
+    // Uncached access!
+    LIBMTP_ERROR("tried to use %s on an unsupported device, "
+                 "this command does not work on all devices "
+                 "due to missing low-level support to read "
+                 "information on individual tracks\n",
+                 __func__);
+    return -1;
+  }
+
+  if (storage == 0)
+    storageid = PTP_GOH_ALL_STORAGE;
+  else
+    storageid = storage;
+
+  ret = ptp_getobjecthandles(params,
+                             storageid,
+                             PTP_GOH_ALL_FORMATS,
+                             parent,
+                             &currentHandles);
+
+  if (ret != PTP_RC_OK) {
+    add_ptp_error_to_errorstack(device, ret,
+        "LIBMTP_Get_Children(): could not get object handles.");
+    return -1;
+  }
+
+  if (currentHandles.Handler == NULL || currentHandles.n == 0)
+    return 0;
+  *out = currentHandles.Handler;
+  return currentHandles.n;
+}
 
 /**
  * This creates a new track metadata structure and allocates memory
  * for it. Notice that if you add strings to this structure they
  * will be freed by the corresponding <code>LIBMTP_destroy_track_t</code>
  * operation later, so be careful of using strdup() when assigning
  * strings, e.g.:
  *
  * <pre>
  * LIBMTP_track_t *track = LIBMTP_new_track_t();
@@ skipping 4519 matching lines @@
  * @param device the device which may have a cache to which the object should be updated.
  * @param object_id the object to update.
  */
 static void update_metadata_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id)
 {
   PTPParams *params = (PTPParams *)device->params;
 
   ptp_remove_object_from_cache(params, object_id);
   add_object_to_cache(device, object_id);
 }