static void
mtp_tracklist_cb (LIBMTP_track_t *tracks, RBMtpSource *source)
{
RhythmDB *db = NULL;
LIBMTP_track_t *track;
/* add tracks to database */
db = get_db_for_source (source);
for (track = tracks; track != NULL; track = track->next) {
add_mtp_track_to_db (source, db, track);
}
g_object_unref (db);
}
static gboolean
impl_track_added (RBRemovableMediaSource *isource,
RhythmDBEntry *entry,
const char *dest,
guint64 filesize,
const char *mimetype)
{
RBMtpSource *source = RB_MTP_SOURCE (isource);
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
GFile *file;
char *path;
LIBMTP_track_t *track = NULL;
file = g_file_new_for_uri (dest);
path = g_file_get_path (file);
track = transfer_track (source, priv->device, entry, path, filesize, mimetype);
g_free (path);
g_file_delete (file, NULL, NULL);
if (track != NULL) {
RhythmDB *db = get_db_for_source (source);
if (priv->album_art_supported) {
const char *album;
album = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM);
if (g_hash_table_lookup (priv->artwork_request_map, album) == NULL) {
GValue *metadata;
rb_debug ("requesting cover art image for album %s", album);
g_hash_table_insert (priv->artwork_request_map, (gpointer) album, GINT_TO_POINTER (1));
metadata = rhythmdb_entry_request_extra_metadata (db, entry, "rb:coverArt");
if (metadata) {
artwork_notify_cb (db, entry, "rb:coverArt", metadata, source);
g_value_unset (metadata);
g_free (metadata);
}
}
}
add_mtp_track_to_db (source, db, track);
g_object_unref (db);
}
return FALSE;
}
static gboolean
impl_track_added (RBTransferTarget *target,
RhythmDBEntry *entry,
const char *dest,
guint64 filesize,
const char *media_type)
{
LIBMTP_track_t *track = NULL;
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (target);
RhythmDB *db;
track = g_hash_table_lookup (priv->track_transfer_map, dest);
if (track == NULL) {
rb_debug ("track-added called, but can't find a track for dest URI %s", dest);
return FALSE;
}
g_hash_table_remove (priv->track_transfer_map, dest);
if (strcmp (track->album, _("Unknown")) != 0) {
rb_mtp_thread_add_to_album (priv->device_thread, track, track->album);
if (priv->album_art_supported) {
RBExtDBKey *key;
/* need to do this in an idle handler? */
key = rb_ext_db_key_create_lookup ("album", track->album);
rb_ext_db_key_add_field (key, "artist", track->artist);
rb_ext_db_request (priv->art_store,
key,
(RBExtDBRequestCallback) art_request_cb,
g_object_ref (target),
(GDestroyNotify) g_object_unref);
rb_ext_db_key_free (key);
}
}
db = get_db_for_source (RB_MTP_SOURCE (target));
add_mtp_track_to_db (RB_MTP_SOURCE (target), db, track);
g_object_unref (db);
queue_free_space_update (RB_MTP_SOURCE (target));
return FALSE;
}
static gboolean
impl_track_added (RBRemovableMediaSource *source,
RhythmDBEntry *entry,
const char *dest,
guint64 filesize,
const char *mimetype)
{
LIBMTP_track_t *track = NULL;
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
RhythmDB *db;
RhythmDBEntry *mtp_entry;
track = g_hash_table_lookup (priv->track_transfer_map, dest);
if (track == NULL) {
rb_debug ("track-added called, but can't find a track for dest URI %s", dest);
return FALSE;
}
g_hash_table_remove (priv->track_transfer_map, dest);
db = get_db_for_source (RB_MTP_SOURCE (source));
/* entry_map takes ownership of the track here */
mtp_entry = add_mtp_track_to_db (RB_MTP_SOURCE (source), db, track);
g_object_unref (db);
if (strcmp (track->album, _("Unknown")) != 0) {
rb_mtp_thread_add_to_album (priv->device_thread, track, track->album);
}
if (priv->album_art_supported) {
RequestAlbumArtData *artdata;
artdata = g_new0 (RequestAlbumArtData, 1);
artdata->source = g_object_ref (source);
artdata->entry = rhythmdb_entry_ref (mtp_entry);
g_idle_add ((GSourceFunc) request_album_art_idle, artdata);
}
queue_free_space_update (RB_MTP_SOURCE (source));
/* chain up to parent class for sync */
RB_REMOVABLE_MEDIA_SOURCE_CLASS (rb_mtp_source_parent_class)->impl_track_added (source, entry, dest, filesize, mimetype);
return FALSE;
}
static gboolean
load_mtp_db_idle_cb (RBMtpSource* source)
{
RhythmDB *db = NULL;
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
LIBMTP_track_t *tracks = NULL;
LIBMTP_album_t *albums;
gboolean device_forgets_albums = TRUE;
db = get_db_for_source (source);
g_assert (db != NULL);
albums = LIBMTP_Get_Album_List (priv->device);
report_libmtp_errors (priv->device, FALSE);
if (albums != NULL) {
LIBMTP_album_t *album;
for (album = albums; album != NULL; album = album->next) {
rb_debug ("album: %s, %d tracks", album->name, album->no_tracks);
g_hash_table_insert (priv->album_map, album->name, album);
if (album->no_tracks != 0) {
device_forgets_albums = FALSE;
}
}
if (device_forgets_albums) {
rb_debug ("stupid mtp device detected. will rebuild all albums.");
}
} else {
rb_debug ("No albums");
device_forgets_albums = FALSE;
}
#ifdef HAVE_LIBMTP_030
tracks = LIBMTP_Get_Tracklisting_With_Callback (priv->device, NULL, NULL);
#else
tracks = LIBMTP_Get_Tracklisting (priv->device);
#endif
report_libmtp_errors (priv->device, FALSE);
if (tracks != NULL) {
LIBMTP_track_t *track;
for (track = tracks; track != NULL; track = track->next) {
add_mtp_track_to_db (source, db, track);
if (device_forgets_albums && track->album != NULL) {
add_track_to_album (source, track->album, track);
}
}
} else {
rb_debug ("No tracks");
}
/* for stupid devices, remove any albums left with no tracks */
if (device_forgets_albums) {
GHashTableIter iter;
gpointer value;
LIBMTP_album_t *album;
g_hash_table_iter_init (&iter, priv->album_map);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
int ret;
album = value;
if (album->no_tracks == 0) {
rb_debug ("pruning empty album \"%s\"", album->name);
ret = LIBMTP_Delete_Object (priv->device, album->album_id);
if (ret != 0) {
report_libmtp_errors (priv->device, FALSE);
}
g_hash_table_iter_remove (&iter);
}
}
}
g_object_unref (G_OBJECT (db));
return FALSE;
}