/* this callback runs on the device handling thread, so it can call libmtp directly */
static void
mtp_device_open_cb (LIBMTP_mtpdevice_t *device, RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
DeviceOpenedData *data;
if (device == NULL) {
/* can't delete the source on this thread, so move it to the main thread */
g_idle_add ((GSourceFunc) device_open_failed_idle, g_object_ref (source));
return;
}
/* set the source name to match the device, ignoring some
* particular broken device names.
*/
data = g_new0 (DeviceOpenedData, 1);
data->source = g_object_ref (source);
data->name = LIBMTP_Get_Friendlyname (device);
if (data->name == NULL || strcmp (data->name, "?????") == 0) {
g_free (data->name);
data->name = LIBMTP_Get_Modelname (device);
}
if (data->name == NULL) {
data->name = g_strdup (_("Digital Audio Player"));
}
/* get some other device information that doesn't change */
priv->manufacturer = LIBMTP_Get_Manufacturername (device);
priv->device_version = LIBMTP_Get_Deviceversion (device);
priv->model_name = LIBMTP_Get_Modelname (device);
priv->serial = LIBMTP_Get_Serialnumber (device);
/* calculate the device capacity */
priv->capacity = 0;
if (LIBMTP_Get_Storage (device, LIBMTP_STORAGE_SORTBY_NOTSORTED) == 0) {
LIBMTP_devicestorage_t *storage;
for (storage = device->storage;
storage != NULL;
storage = storage->next) {
priv->capacity += storage->MaxCapacity;
}
}
update_free_space_cb (device, RB_MTP_SOURCE (source));
/* figure out the set of formats supported by the device */
if (LIBMTP_Get_Supported_Filetypes (device, &data->types, &data->num_types) != 0) {
rb_mtp_thread_report_errors (priv->device_thread, FALSE);
}
g_idle_add ((GSourceFunc) device_opened_idle, data);
/* now get the track list */
rb_mtp_thread_get_track_list (priv->device_thread, (RBMtpTrackListCallback) mtp_tracklist_cb, g_object_ref (source), g_object_unref);
}
/* this callback runs on the device handling thread, so it can call libmtp directly */
static void
mtp_device_open_cb (LIBMTP_mtpdevice_t *device, RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
gboolean has_audio = FALSE;
DeviceOpenedData *data;
if (device == NULL) {
/* can't delete the source on this thread, so move it to the main thread */
g_idle_add ((GSourceFunc) device_open_failed_idle, g_object_ref (source));
return;
}
/* set the source name to match the device, ignoring some
* particular broken device names.
*/
data = g_new0 (DeviceOpenedData, 1);
data->source = g_object_ref (source);
data->name = LIBMTP_Get_Friendlyname (device);
if (data->name == NULL || strcmp (data->name, "?????") == 0) {
g_free (data->name);
data->name = LIBMTP_Get_Modelname (device);
}
if (data->name == NULL) {
data->name = g_strdup (_("Digital Audio Player"));
}
/* get some other device information that doesn't change */
priv->manufacturer = LIBMTP_Get_Manufacturername (device);
priv->device_version = LIBMTP_Get_Deviceversion (device);
priv->model_name = LIBMTP_Get_Modelname (device);
priv->serial = LIBMTP_Get_Serialnumber (device);
/* calculate the device capacity */
priv->capacity = 0;
if (LIBMTP_Get_Storage (device, LIBMTP_STORAGE_SORTBY_NOTSORTED) == 0) {
LIBMTP_devicestorage_t *storage;
for (storage = device->storage;
storage != NULL;
storage = storage->next) {
priv->capacity += storage->MaxCapacity;
}
}
update_free_space_cb (device, RB_MTP_SOURCE (source));
/* figure out the set of formats supported by the device, ensuring there's at least
* one audio format aside from WAV. the purpose of this is to exclude cameras and other
* MTP devices that aren't interesting to us.
*/
if (LIBMTP_Get_Supported_Filetypes (device, &data->types, &data->num_types) != 0) {
rb_mtp_thread_report_errors (priv->device_thread, FALSE);
} else {
int i;
for (i = 0; i < data->num_types; i++) {
if (data->types[i] != LIBMTP_FILETYPE_WAV && LIBMTP_FILETYPE_IS_AUDIO (data->types[i])) {
has_audio = TRUE;
break;
}
}
}
if (has_audio == FALSE) {
rb_debug ("device doesn't support any audio formats");
g_idle_add ((GSourceFunc) device_open_ignore_idle, data);
return;
}
g_idle_add ((GSourceFunc) device_opened_idle, data);
/* now get the track list */
rb_mtp_thread_get_track_list (priv->device_thread, (RBMtpTrackListCallback) mtp_tracklist_cb, g_object_ref (source), g_object_unref);
}
static int
Device_init(Device *self, PyObject *args, PyObject *kwds)
{
unsigned long busnum;
unsigned char devnum;
unsigned short vendor_id, product_id;
PyObject *usb_serialnum;
char *vendor, *product, *friendly_name, *manufacturer_name, *model_name, *serial_number, *device_version;
LIBMTP_raw_device_t *rawdevs = NULL, rdev;
int numdevs, c, tried_count = 0;
LIBMTP_mtpdevice_t *dev = NULL;
LIBMTP_error_number_t err;
if (!PyArg_ParseTuple(args, "kBHHssO", &busnum, &devnum, &vendor_id, &product_id, &vendor, &product, &usb_serialnum)) return -1;
// We have to build and search the rawdevice list instead of creating a
// rawdevice directly as otherwise, dynamic bug flag assignment in libmtp
// does not work
Py_BEGIN_ALLOW_THREADS;
err = LIBMTP_Detect_Raw_Devices(&rawdevs, &numdevs);
Py_END_ALLOW_THREADS;
if (err == LIBMTP_ERROR_NO_DEVICE_ATTACHED) { PyErr_SetString(MTPError, "No raw devices found"); return -1; }
if (err == LIBMTP_ERROR_CONNECTING) { PyErr_SetString(MTPError, "There has been an error connecting"); return -1; }
if (err == LIBMTP_ERROR_MEMORY_ALLOCATION) { PyErr_NoMemory(); return -1; }
if (err != LIBMTP_ERROR_NONE) { PyErr_SetString(MTPError, "Failed to detect raw MTP devices"); return -1; }
for (c = 0; c < numdevs; c++) {
rdev = rawdevs[c];
if (rdev.bus_location == (uint32_t)busnum && rdev.devnum == (uint8_t)devnum) {
tried_count += 1;
Py_BEGIN_ALLOW_THREADS;
dev = LIBMTP_Open_Raw_Device_Uncached(&rdev);
Py_END_ALLOW_THREADS;
if (dev != NULL) break;
}
}
if (rawdevs != NULL) free(rawdevs);
if (dev == NULL) {
if (tried_count == 0) PyErr_Format(MTPError, "No device with busnum=%lu and devnum=%u found", busnum, devnum);
else PyErr_Format(MTPError, "Unable to open MTP device with busnum=%lu and devnum=%u, tried %d such devices", busnum, devnum, tried_count);
return -1;
}
self->device = dev;
self->ids = Py_BuildValue("kBHHO", busnum, devnum, vendor_id, product_id, usb_serialnum);
if (self->ids == NULL) return -1;
Py_BEGIN_ALLOW_THREADS;
friendly_name = LIBMTP_Get_Friendlyname(self->device);
manufacturer_name = LIBMTP_Get_Manufacturername(self->device);
model_name = LIBMTP_Get_Modelname(self->device);
serial_number = LIBMTP_Get_Serialnumber(self->device);
device_version = LIBMTP_Get_Deviceversion(self->device);
Py_END_ALLOW_THREADS;
if (friendly_name != NULL) {
self->friendly_name = PyUnicode_FromString(friendly_name);
free(friendly_name);
}
if (self->friendly_name == NULL) { self->friendly_name = Py_None; Py_INCREF(Py_None); }
if (manufacturer_name != NULL) {
self->manufacturer_name = PyUnicode_FromString(manufacturer_name);
free(manufacturer_name);
}
if (self->manufacturer_name == NULL) { self->manufacturer_name = Py_None; Py_INCREF(Py_None); }
if (model_name != NULL) {
self->model_name = PyUnicode_FromString(model_name);
free(model_name);
}
if (self->model_name == NULL) { self->model_name = Py_None; Py_INCREF(Py_None); }
if (serial_number != NULL) {
self->serial_number = PyUnicode_FromString(serial_number);
free(serial_number);
}
if (self->serial_number == NULL) { self->serial_number = Py_None; Py_INCREF(Py_None); }
if (device_version != NULL) {
self->device_version = PyUnicode_FromString(device_version);
free(device_version);
}
if (self->device_version == NULL) { self->device_version = Py_None; Py_INCREF(Py_None); }
return 0;
}
