/**
* Get the first (as in "first in the list of") connected Vita MTP device.
* @return a device pointer. NULL if error, no connected device, or no connected Vita
* @see LIBMTP_Get_Connected_Devices()
*/
LIBMTP_mtpdevice_t *LIBVitaMTP_Get_First_Vita(void){
LIBMTP_mtpdevice_t *first_device = NULL;
LIBMTP_raw_device_t *devices;
int numdevs;
int i;
LIBMTP_error_number_t ret;
ret = LIBMTP_Detect_Raw_Devices(&devices, &numdevs);
if (ret != LIBMTP_ERROR_NONE){
return NULL;
}
if (devices == NULL || numdevs == 0){
return NULL;
}
for (i = 0; i < numdevs; i++){
if(devices[i].device_entry.vendor_id == VITA_VID &&
devices[i].device_entry.product_id == VITA_PID){
first_device = LIBMTP_Open_Raw_Device(&devices[i]);
break;
}
LIBMTP_Release_Device(first_device);
}
free(devices);
return first_device; // NULL if no vita
}
/*****************************************************************************
* Everything else
*****************************************************************************/
static int AddDevice( services_discovery_t *p_sd,
LIBMTP_raw_device_t *p_raw_device )
{
char *psz_name = NULL;
LIBMTP_mtpdevice_t *p_device;
LIBMTP_track_t *p_track, *p_tmp;
if( ( p_device = LIBMTP_Open_Raw_Device( p_raw_device ) ) != NULL )
{
if( !( psz_name = LIBMTP_Get_Friendlyname( p_device ) ) )
if( !( psz_name = LIBMTP_Get_Modelname( p_device ) ) )
if( !( psz_name = strdup( N_( "MTP Device" ) ) ) )
return VLC_ENOMEM;
msg_Info( p_sd, "Found device: %s", psz_name );
p_sd->p_sys->i_bus = p_raw_device->bus_location;
p_sd->p_sys->i_dev = p_raw_device->devnum;
p_sd->p_sys->i_product_id = p_raw_device->device_entry.product_id;
if( ( p_track = LIBMTP_Get_Tracklisting_With_Callback( p_device,
CountTracks, p_sd ) ) == NULL )
{
msg_Warn( p_sd, "No tracks on the device" );
}
else
{
if( !( p_sd->p_sys->pp_items = calloc( p_sd->p_sys->i_tracks_num,
sizeof( input_item_t * ) ) ) )
{
free( psz_name );
return VLC_ENOMEM;
}
p_sd->p_sys->i_count = 0;
while( p_track != NULL )
{
msg_Dbg( p_sd, "Track found: %s - %s", p_track->artist,
p_track->title );
AddTrack( p_sd, p_track );
p_tmp = p_track;
p_track = p_track->next;
LIBMTP_destroy_track_t( p_tmp );
}
}
p_sd->p_sys->psz_name = psz_name;
LIBMTP_Release_Device( p_device );
return VLC_SUCCESS;
}
else
{
msg_Info( p_sd, "The device seems to be mounted, unmount it first" );
return VLC_EGENERIC;
}
}
void Plugin::Upload (const QString& localPath, const QString& origPath, const QByteArray& devId, const QByteArray& storageId)
{
qDebug () << Q_FUNC_INFO << IsPolling_ << localPath << devId;
if (IsPolling_)
{
UploadQueue_.append ({ localPath, origPath, devId, storageId });
return;
}
if (!DevicesCache_.contains (devId))
{
qDebug () << "device not in cache, opening...";
bool found = false;
LIBMTP_raw_device_t *rawDevices;
int numRawDevices = 0;
LIBMTP_Detect_Raw_Devices (&rawDevices, &numRawDevices);
for (int i = 0; i < numRawDevices; ++i)
{
std::shared_ptr<LIBMTP_mtpdevice_t> device (LIBMTP_Open_Raw_Device (&rawDevices [i]), LIBMTP_Release_Device);
if (!device)
continue;
const auto& serial = LIBMTP_Get_Serialnumber (device.get ());
qDebug () << "matching against" << serial;
if (serial == devId)
{
DevicesCache_ [devId] = DeviceCacheEntry { std::move (device) };
found = true;
break;
}
}
free (rawDevices);
if (!found)
{
qWarning () << Q_FUNC_INFO
<< "unable to find device"
<< devId;
emit uploadFinished (localPath,
QFile::ResourceError,
tr ("Unable to find the requested device."));
return;
}
}
const auto& entry = DevicesCache_ [devId];
UploadTo (entry.Device_.get (), storageId, localPath, origPath);
}
static void
open_device (RBMtpThread *thread, RBMtpThreadTask *task)
{
RBMtpOpenCallback cb = task->callback;
int retry;
/* open the device */
rb_debug ("attempting to open retry device");
for (retry = 0; retry < 5; retry++) {
if (retry > 0) {
/* sleep a while before trying again */
g_usleep (G_USEC_PER_SEC);
}
thread->device = LIBMTP_Open_Raw_Device (task->raw_device);
if (thread->device != NULL) {
break;
}
rb_debug ("attempt %d failed..", retry+1);
}
cb (thread->device, task->user_data);
}
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;
}
