static GrlMedia *
build_media(gint track_id,
const gchar *artist_name,
const gchar *album_name,
const gchar *track_name,
gint track_number,
gint duration,
const gchar *url_to_mp3,
GPtrArray *url_to_covers)
{
GrlMedia *media = NULL;
gchar *str_track_id = NULL;
media = grl_media_audio_new();
grl_media_set_track_number(media, track_number);
grl_media_set_artist(media, artist_name);
grl_media_set_album(media, album_name);
grl_media_set_url(media, url_to_mp3);
grl_media_set_duration(media, duration);
grl_media_set_title(media, track_name);
g_ptr_array_foreach(url_to_covers, add_cover, media);
str_track_id = g_strdup_printf("%d", track_id);
grl_media_set_id(media, str_track_id);
g_free(str_track_id);
return media;
}
static GrlMedia *
create_media (sqlite3_stmt * stmt, GList *keys)
{
GrlMedia *media;
gint media_type;
media_type = sqlite3_column_int (stmt, STORE_TYPE_ID);
switch (media_type) {
case MEDIA_AUDIO:
media = grl_media_audio_new ();
break;
case MEDIA_VIDEO:
media = grl_media_video_new ();
break;
case MEDIA_IMAGE:
media = grl_media_image_new ();
break;
case MEDIA_BOX:
media = grl_media_box_new ();
break;
default:
media = grl_media_new ();
}
grl_media_set_source (media,
(const gchar *) sqlite3_column_text (stmt, STORE_SOURCE_ID));
grl_media_set_id (media,
(const gchar *) sqlite3_column_text (stmt, STORE_MEDIA_ID));
fill_metadata_from_stmt (media, keys, stmt);
return media;
}
static GrlMedia *
create_media_from_mount (GMount *mount)
{
char *id;
GrlMedia *media;
/* Is it an audio CD or a blank media */
if (ignore_mount (mount)) {
GRL_DEBUG ("%s: Ignoring mount %s", __FUNCTION__,
g_mount_get_name (mount));
g_object_unref (mount);
return NULL;
}
id = create_mount_id (mount);
if (id == NULL) {
GRL_DEBUG ("%s: Not adding mount %s as has no device path", __FUNCTION__,
g_mount_get_name (mount));
return NULL;
}
media = grl_media_video_new ();
grl_media_set_id (media, id);
g_free (id);
media_set_metadata (mount, media);
grl_media_set_mime (media, "x-special/device-block");
GRL_DEBUG ("%s: Adding mount %s (id: %s)", __FUNCTION__,
g_mount_get_name (mount), grl_media_get_id (media));
return media;
}
static void
tracker_evt_update_items_cb (gpointer key,
gpointer value,
tracker_evt_update_t *evt)
{
guint id = GPOINTER_TO_INT (key);
gchar *str_id;
GrlTrackerSource *source = (GrlTrackerSource *) value;
GrlMedia *media;
GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);
if (!source) {
g_assert ("\tnot in cache ???");
return;
}
if (!grl_tracker_source_can_notify (source)) {
GRL_DEBUG ("\tno notification for source %s...",
grl_source_get_name (GRL_SOURCE (source)));
return;
}
media = grl_media_new ();
str_id = g_strdup_printf ("%i", id);
grl_media_set_id (media, str_id);
g_free (str_id);
GRL_DEBUG ("\tNotify id=%u source=%s", id,
grl_source_get_name (GRL_SOURCE (source)));
grl_source_notify_change (GRL_SOURCE (source), media, evt->change_type, FALSE);
g_object_unref (media);
}
static GrlMedia *
build_media(gint track_id,
const gchar *artist_name,
const gchar *album_name,
const gchar *track_name,
gint track_number,
gint duration,
const gchar *url_to_mp3)
{
GrlMedia *media = NULL;
GrlMediaAudio *audio = NULL;
gchar *str_track_id = NULL;
media = grl_media_audio_new();
audio = GRL_MEDIA_AUDIO(media);
grl_media_audio_set_track_number(audio, track_number);
grl_media_audio_set_artist(audio, artist_name);
grl_media_audio_set_album(audio, album_name);
grl_media_set_url(media, url_to_mp3);
grl_media_set_duration(media, duration);
grl_media_set_title(media, track_name);
str_track_id = g_strdup_printf("%d", track_id);
grl_media_set_id(media, str_track_id);
g_free(str_track_id);
return media;
}
static GrlMedia *
produce_container_from_directory (GrlMedia *media,
CategoryInfo *dir,
guint index,
RaitvMediaType type)
{
GrlMedia *content;
gchar* mediaid=NULL;
if (!media) {
content = grl_media_box_new ();
} else {
content = media;
}
if (!dir) {
grl_media_set_id (content, NULL);
grl_media_set_title (content, RAITV_ROOT_NAME);
} else {
switch(type)
{
case RAITV_MEDIA_TYPE_ROOT :
case RAITV_MEDIA_TYPE_POPULARS :
case RAITV_MEDIA_TYPE_RECENTS :
mediaid = g_strdup_printf("%s",dir[index].id);
break;
case RAITV_MEDIA_TYPE_POPULAR_THEME :
mediaid = g_strdup_printf("%s/%s", RAITV_POPULARS_THEME_ID, dir[index].id);
break;
case RAITV_MEDIA_TYPE_RECENT_THEME :
mediaid = g_strdup_printf("%s/%s", RAITV_RECENTS_THEME_ID, dir[index].id);
break;
default:
break;
}
GRL_DEBUG ("MediaId=%s, Type:%d, Titolo:%s",mediaid, type, dir[index].name);
grl_media_set_id (content, mediaid);
grl_media_set_title (content, g_dgettext (GETTEXT_PACKAGE, dir[index].name));
g_free(mediaid);
}
return content;
}
static GrlMedia *
create_media_box (GrlDvbDaemonExporter *self)
{
GrlMedia * box = GRL_MEDIA (grl_media_box_new ());
grl_media_set_id (box, self->priv->channel_list_path);
grl_media_set_title (box, self->priv->name);
return box;
}
static void
magnatune_browse_root(OperationSpec *os)
{
GrlMedia *media = NULL;
guint num = 0;
gchar *id = NULL;
GRL_DEBUG("magnatune_browse_root");
if (os->skip > 1 || os->count == 0) {
os->callback(os->source, os->operation_id, NULL, 0, os->user_data, NULL);
return;
}
num = (os->count > MAGNATUNE_NUM_CAT) ? MAGNATUNE_NUM_CAT: os->count;
media = grl_media_box_new();
grl_media_set_title(media, MAGNATUNE_ROOT_ARTIST);
id = g_strdup_printf("root-%d", MAGNATUNE_ARTIST_CAT);
grl_media_set_id(media, id);
num--;
os->callback(os->source, os->operation_id, media, num, os->user_data, NULL);
g_free(id);
if (num == 0)
return;
media = grl_media_box_new();
grl_media_set_title(media, MAGNATUNE_ROOT_ALBUM);
id = g_strdup_printf("root-%d", MAGNATUNE_ALBUM_CAT);
grl_media_set_id(media, id);
num--;
os->callback(os->source, os->operation_id, media, num, os->user_data, NULL);
g_free(id);
if (num == 0)
return;
media = grl_media_box_new();
grl_media_set_title(media, MAGNATUNE_ROOT_GENRE);
id = g_strdup_printf("root-%d", MAGNATUNE_GENRE_CAT);
grl_media_set_id(media, id);
num--;
os->callback(os->source, os->operation_id, media, num, os->user_data, NULL);
g_free(id);
}
static GList *
add_volume (GList *media_list,
GVolume *volume,
GDrive *drive,
GrlOpticalMediaSource *source)
{
char *name, *icon_uri;
GIcon *icon;
char *device_path, *id;
GrlMedia * media;
GMount *mount;
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (device_path == NULL)
return media_list;
/* Is it an audio CD or a blank media */
mount = g_volume_get_mount (volume);
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
g_object_unref (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
g_free (device_path);
return media_list;
}
g_object_unref (root);
}
media = grl_media_video_new ();
id = g_filename_to_uri (device_path, NULL, NULL);
g_free (device_path);
grl_media_set_id (media, id);
g_free (id);
/* Work out an icon to display */
icon = g_volume_get_icon (volume);
icon_uri = get_uri_for_gicon (icon);
g_object_unref (icon);
grl_media_set_thumbnail (media, icon_uri);
g_free (icon_uri);
/* Get the volume's pretty name for the menu label */
name = g_volume_get_name (volume);
g_strstrip (name);
grl_media_set_title (media, name);
g_free (name);
grl_media_set_mime (media, "x-special/device-block");
return g_list_prepend (media_list, media);
}
static void
magnatune_execute_search(OperationSpec *os)
{
GrlMedia *media = NULL;
gchar *sql = NULL;
GList *list_medias = NULL;
GList *iter = NULL;
gint num_medias = 0;
gchar *id = NULL;
GError *err = NULL;
GRL_DEBUG("magnatune_execute_search");
sql = g_strdup_printf(GRL_SQL_SONGS_QUERY_ALL,
os->text, os->text, os->text,
os->count, os->skip);
list_medias = magnatune_sqlite_execute(os,
sql,
build_media_track_from_stmt,
&err);
g_free(sql);
if (list_medias == NULL)
goto end_search;
num_medias = g_list_length(list_medias) - 1;
for (iter = list_medias; iter; iter = iter->next) {
media = iter->data;
id = g_strdup_printf("%s-%s", "track", grl_media_get_id(media));
grl_media_set_id(media, id);
g_free(id);
os->callback(os->source,
os->operation_id,
media,
num_medias,
os->user_data,
NULL);
num_medias--;
}
g_list_free(list_medias);
g_slice_free(OperationSpec, os);
return;
end_search:
if (err != NULL) {
os->callback(os->source, os->operation_id, NULL, 0, os->user_data, err);
g_error_free(err);
} else {
os->callback(os->source, os->operation_id, NULL, 0, os->user_data, NULL);
}
g_slice_free(OperationSpec, os);
}
static void
execute_resolve_test (const gchar *test_id)
{
GrlSource *source;
GrlMedia *media;
GrlOperationOptions *options;
GList *keys;
set_test_data (&source, &media, &options, &keys, GRL_OP_RESOLVE);
grl_media_set_id (media, test_id);
grl_source_resolve_sync (source, media, keys, options, NULL);
free_test_data (&media, &options, &keys);
}
static GrlMedia*
build_media_id_name_from_stmt(sqlite3_stmt *sql_stmt)
{
GrlMedia *media = NULL;
guint media_id = 0;
gchar *id = NULL;
const gchar *media_name = NULL;
media = grl_media_box_new();
media_id = (guint) sqlite3_column_int(sql_stmt, 0);
media_name = (gchar *) sqlite3_column_text(sql_stmt, 1);
id = g_strdup_printf("%d", media_id);
grl_media_set_id(media, id);
grl_media_set_title(media, media_name);
g_free(id);
return media;
}
static void
add_model (MexBliptvPlugin *self,
GrlSource *source)
{
MexFeed *feed;
GrlMedia *box;
box = grl_media_video_new ();
grl_media_set_id (GRL_MEDIA (box), NULL);
feed = mex_grilo_feed_new (source,
self->priv->query_keys,
self->priv->video_keys, box);
g_object_set (feed, "icon-name", "icon-panelheader-computer",
"placeholder-text", "No videos found",
"category", "videos",
NULL);
mex_grilo_feed_browse (MEX_GRILO_FEED (feed), 0, 100);
g_hash_table_insert (self->priv->video_models, source, feed);
mex_model_manager_add_model (self->priv->manager, MEX_MODEL (feed));
}
static void
add_model (MexTrackerPlugin *self,
GrlMediaPlugin *plugin,
MexTrackerCategory category)
{
GList *metadata_keys, *query_keys;
MexFeed *feed, *dir_feed;
GrlMedia *box;
gchar *query, *cat_name;
GHashTable *models;
const gchar *source_name = grl_metadata_source_get_name (GRL_METADATA_SOURCE (plugin));
gint priority;
switch (category)
{
case MEX_TRACKER_CATEGORY_IMAGE:
cat_name = "pictures";
query = "?urn a nfo:FileDataObject . "
"?urn tracker:available true . "
"FILTER (fn:starts-with(nie:mimeType(?urn),'image/'))";
models = self->priv->image_models;
metadata_keys = self->priv->image_keys;
query_keys = self->priv->query_image_keys;
box = grl_media_image_new ();
break;
case MEX_TRACKER_CATEGORY_VIDEO:
cat_name = "videos";
query = "?urn a nfo:FileDataObject . "
"?urn tracker:available true . "
"FILTER (fn:starts-with(nie:mimeType(?urn),'video/'))";
models = self->priv->video_models;
metadata_keys = self->priv->video_keys;
query_keys = self->priv->query_video_keys;
box = grl_media_video_new ();
break;
case MEX_TRACKER_CATEGORY_MUSIC:
cat_name = "music";
query = "?urn a nfo:FileDataObject . "
"?urn tracker:available true . "
"FILTER (fn:starts-with(nie:mimeType(?urn),'audio/'))";
models = self->priv->music_models;
metadata_keys = self->priv->music_keys;
query_keys = self->priv->query_music_keys;
box = grl_media_audio_new ();
break;
}
grl_media_set_id (GRL_MEDIA (box), NULL);
feed = mex_grilo_tracker_feed_new (GRL_MEDIA_SOURCE (plugin),
query_keys,
metadata_keys,
NULL, box);
mex_model_set_sort_func (MEX_MODEL (feed),
mex_model_sort_time_cb,
GINT_TO_POINTER (TRUE));
mex_grilo_feed_query (MEX_GRILO_FEED (feed), query, 0, MAX_TRACKER_RESULTS);
g_hash_table_insert (models, plugin, feed);
/* set the local files source to appear first */
if (!g_strcmp0 (source_name, "Local files"))
priority = -100;
else
priority = 0;
dir_feed = mex_grilo_tracker_feed_new (GRL_MEDIA_SOURCE (plugin),
query_keys,
metadata_keys,
query, NULL);
mex_model_set_sort_func (MEX_MODEL (dir_feed),
mex_model_sort_alpha_cb,
GINT_TO_POINTER (FALSE));
mex_grilo_feed_browse (MEX_GRILO_FEED (dir_feed), 0, G_MAXINT);
g_object_set (G_OBJECT (feed),
"category", cat_name,
"priority", priority,
"alt-model", dir_feed,
"alt-model-string", _("Show Folders"),
NULL);
mex_model_manager_add_model (self->priv->manager, MEX_MODEL (feed));
}
static void
tracker_evt_update_orphans (tracker_evt_update_t *evt)
{
gboolean first = TRUE;
GString *request_str;
GList *subject, *subjects;
GList *source, *sources;
GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);
if (g_hash_table_size (evt->orphan_items) < 1) {
tracker_evt_postupdate_sources (evt);
return;
}
sources = grl_registry_get_sources (grl_registry_get_default (),
FALSE);
request_str = g_string_new ("");
subjects = g_hash_table_get_keys (evt->orphan_items);
subject = subjects;
while (subject != NULL) {
guint id = GPOINTER_TO_INT (subject->data);
if (GPOINTER_TO_INT (g_hash_table_lookup (evt->orphan_items,
subject->data)) != GRL_CONTENT_REMOVED) {
if (first) {
g_string_append_printf (request_str, "%u", id);
first = FALSE;
}
else {
g_string_append_printf (request_str, ", %u", id);
}
} else {
/* Notify all sources that a media been removed */
source = sources;
while (source != NULL) {
if (GRL_IS_TRACKER_SOURCE (source->data)) {
GRL_DEBUG ("\tNotify id=%u source=%s p=%p", id,
grl_source_get_name (GRL_SOURCE (source->data)),
source->data);
if (grl_tracker_source_can_notify (GRL_TRACKER_SOURCE (source->data))) {
GrlMedia *media = grl_media_new ();
gchar *str_id = g_strdup_printf ("%u", id);
grl_media_set_id (media, str_id);
g_free (str_id);
grl_source_notify_change (GRL_SOURCE (source->data),
media,
GRL_CONTENT_REMOVED,
FALSE);
g_object_unref (media);
}
}
source = source->next;
}
}
subject = subject->next;
}
g_list_free (subjects);
if (request_str->len > 0) {
gchar *sparql_final = g_strdup_printf (TRACKER_MEDIA_ITEM, request_str->str);
GRL_DEBUG ("\trequest : '%s'", sparql_final);
tracker_sparql_connection_query_async (grl_tracker_connection,
sparql_final,
NULL,
(GAsyncReadyCallback) tracker_evt_update_orphans_cb,
evt);
g_free (sparql_final);
} else {
tracker_evt_postupdate_sources (evt);
}
g_string_free (request_str, TRUE);
}
static void
store_bookmark (GrlBookmarksSource *bookmarks_source,
GList **keylist,
GrlMediaBox *parent,
GrlMedia *bookmark,
GError **error)
{
GomResource *resource;
const gchar *title;
const gchar *url;
const gchar *desc;
const gchar *thumb;
GTimeVal now;
gint64 parent_id;
const gchar *mime;
gchar *date;
guint type;
gint64 id;
gchar *str_id;
GError *local_error = NULL;
gboolean ret;
GRL_DEBUG ("store_bookmark");
title = grl_media_get_title (bookmark);
url = grl_media_get_url (bookmark);
thumb = grl_media_get_thumbnail (bookmark);
desc = grl_media_get_description (bookmark);
mime = grl_media_get_mime (bookmark);
g_get_current_time (&now);
date = g_time_val_to_iso8601 (&now);
if (!parent) {
parent_id = 0;
} else {
parent_id = g_ascii_strtoll (grl_media_get_id (GRL_MEDIA (parent)), NULL, 0);
}
if (parent_id < 0) {
parent_id = 0;
}
GRL_DEBUG ("URL: '%s'", url);
if (GRL_IS_MEDIA_BOX (bookmark)) {
type = BOOKMARK_TYPE_CATEGORY;
} else {
type = BOOKMARK_TYPE_STREAM;
}
resource = g_object_new (BOOKMARKS_TYPE_RESOURCE,
"repository", bookmarks_source->priv->repository,
"parent", parent_id,
"type", type,
NULL);
if (type == BOOKMARK_TYPE_STREAM) {
g_object_set (G_OBJECT (resource), "url", url, NULL);
*keylist = g_list_remove (*keylist,
GRLKEYID_TO_POINTER (GRL_METADATA_KEY_URL));
}
if (title) {
g_object_set (G_OBJECT (resource), "title", title, NULL);
*keylist = g_list_remove (*keylist,
GRLKEYID_TO_POINTER (GRL_METADATA_KEY_TITLE));
} else if (url) {
g_object_set (G_OBJECT (resource), "title", url, NULL);
} else {
g_object_set (G_OBJECT (resource), "title", "(unknown)", NULL);
}
if (date) {
g_object_set (G_OBJECT (resource), "date", date, NULL);
}
if (mime) {
g_object_set (G_OBJECT (resource), "mime", mime, NULL);
*keylist = g_list_remove (*keylist,
GRLKEYID_TO_POINTER (GRL_METADATA_KEY_MIME));
}
if (desc) {
g_object_set (G_OBJECT (resource), "desc", desc, NULL);
*keylist = g_list_remove (*keylist,
GRLKEYID_TO_POINTER (GRL_METADATA_KEY_DESCRIPTION));
}
if (thumb) {
g_object_set (G_OBJECT (resource), "thumbnail-url", desc, NULL);
*keylist = g_list_remove (*keylist,
GRLKEYID_TO_POINTER (GRL_METADATA_KEY_THUMBNAIL));
}
ret = gom_resource_save_sync (resource, &local_error);
if (!ret) {
GRL_WARNING ("Failed to store bookmark '%s': %s", title,
local_error->message);
*error = g_error_new (GRL_CORE_ERROR,
GRL_CORE_ERROR_STORE_FAILED,
_("Failed to store: %s"),
local_error->message);
g_error_free (local_error);
g_object_unref (resource);
return;
}
g_object_get (resource, "id", &id, NULL);
str_id = g_strdup_printf ("%" G_GINT64_FORMAT, id);
grl_media_set_id (bookmark, str_id);
g_free (str_id);
g_object_unref (resource);
if (bookmarks_source->priv->notify_changes) {
grl_source_notify_change (GRL_SOURCE (bookmarks_source),
bookmark,
GRL_CONTENT_ADDED,
FALSE);
}
}
static GrlMedia *
build_media_from_resource (GrlMedia *content,
GomResource *resource,
GrlTypeFilter type_filter)
{
GrlMedia *media = NULL;
gint64 id;
gchar *str_id;
gchar *title;
gchar *url;
gchar *desc;
gchar *date;
gchar *mime;
gchar *thumb;
guint type;
if (content) {
media = content;
}
g_object_get (resource,
"id", &id,
"title", &title,
"url", &url,
"desc", &desc,
"date", &date,
"mime", &mime,
"type", &type,
"thumbnail-url", &thumb,
NULL);
if (!media) {
if (type == BOOKMARK_TYPE_CATEGORY) {
media = GRL_MEDIA (grl_media_box_new ());
} else if (mime_is_audio (mime)) {
if (type_filter & GRL_TYPE_FILTER_AUDIO)
media = GRL_MEDIA (grl_media_new ());
} else if (mime_is_video (mime)) {
if (type_filter & GRL_TYPE_FILTER_VIDEO)
media = GRL_MEDIA (grl_media_new ());
} else if (mime_is_image (mime)) {
if (type_filter & GRL_TYPE_FILTER_IMAGE)
media = GRL_MEDIA (grl_media_image_new ());
} else {
if (type_filter != GRL_TYPE_FILTER_NONE)
media = GRL_MEDIA (grl_media_new ());
}
}
if (!media)
return NULL;
str_id = g_strdup_printf ("%" G_GINT64_FORMAT, id);
grl_media_set_id (media, str_id);
g_free (str_id);
grl_media_set_title (media, title);
if (url) {
grl_media_set_url (media, url);
}
if (desc) {
grl_media_set_description (media, desc);
}
if (date) {
GDateTime *date_time = grl_date_time_from_iso8601 (date);
if (date_time) {
grl_data_set_boxed (GRL_DATA (media),
GRL_BOOKMARKS_KEY_BOOKMARK_TIME,
date_time);
g_date_time_unref (date_time);
}
}
if (thumb) {
grl_media_set_thumbnail (media, thumb);
}
g_free (title);
g_free (url);
g_free (desc);
g_free (date);
g_free (mime);
g_free (thumb);
return media;
}
static void
magnatune_execute_browse(OperationSpec *os)
{
MagnatuneBuildMediaFn *build_fn;
GrlMedia *media = NULL;
const gchar *container_id = NULL;
gchar *sql = NULL;
gchar **touple = NULL;
gchar *box_id = NULL;
gchar *category_str_id = NULL;
gint id = 0;
gint num_medias = 0;
static GList *iter = NULL;
static GList *list_medias = NULL;
GError *err = NULL;
GRL_DEBUG("magnatune_execute_browse");
container_id = grl_media_get_id(os->container);
if (container_id == NULL) {
magnatune_browse_root(os);
goto end_browse;
}
touple = g_strsplit_set(container_id, MAGNATUNE_NAME_ID_SEP, 0);
id = g_ascii_strtoll(touple[1], NULL, 10);
build_fn = build_media_id_name_from_stmt;
if (strcmp(touple[0], "root") == 0) {
switch (id) {
case MAGNATUNE_ARTIST_CAT:
category_str_id = g_strdup("artist");
sql = g_strdup_printf(GRL_SQL_ARTISTS_QUERY_ALL, os->count, os->skip);
break;
case MAGNATUNE_ALBUM_CAT:
category_str_id = g_strdup("album");
sql = g_strdup_printf(GRL_SQL_ALBUMS_QUERY_ALL, os->count, os->skip);
break;
case MAGNATUNE_GENRE_CAT:
category_str_id = g_strdup("genre");
sql = g_strdup_printf(GRL_SQL_GENRES_QUERY_ALL, os->count, os->skip);
break;
}
} else if (strcmp(touple[0], "artist") == 0) {
category_str_id = g_strdup("album");
sql = g_strdup_printf(GRL_SQL_ALBUMS_BY_ARTIST, id, os->count, os->skip);
} else if (strcmp(touple[0], "album") == 0) {
category_str_id = g_strdup("track");
sql = g_strdup_printf(GRL_SQL_SONGS_BY_ALBUM, id, os->count, os->skip);
build_fn = build_media_track_from_stmt;
} else if (strcmp(touple[0], "genre") == 0) {
category_str_id = g_strdup("album");
sql = g_strdup_printf(GRL_SQL_ALBUMS_BY_GENRE, id, os->count, os->skip);
} else {
err = g_error_new(GRL_CORE_ERROR,
GRL_CORE_ERROR_BROWSE_FAILED,
_("Invalid container identifier %s"),
container_id);
}
g_strfreev(touple);
if (sql == NULL || err != NULL)
goto end_browse;
/* We have the right sql-query, execute */
list_medias = magnatune_sqlite_execute(os, sql, build_fn, &err);
g_free(sql);
if (list_medias == NULL)
goto end_browse;
num_medias = g_list_length(list_medias) - 1;;
for (iter = list_medias; iter; iter = iter->next) {
media = iter->data;
box_id = g_strdup_printf("%s-%s",
category_str_id,
grl_media_get_id(media));
grl_media_set_id(media, box_id);
g_free(box_id);
os->callback(os->source,
os->operation_id,
media,
num_medias,
os->user_data,
NULL);
num_medias--;
}
g_list_free(list_medias);
end_browse:
if (err != NULL) {
os->callback(os->source, os->operation_id, NULL, 0, os->user_data, err);
g_error_free(err);
}
g_clear_pointer (&category_str_id, g_free);
g_slice_free(OperationSpec, os);
}
static void
update_media (GrlMedia *media, GHashTable *video)
{
gchar *str;
str = g_hash_table_lookup (video, VIMEO_VIDEO_ID);
if (str)
{
char *external_url;
grl_media_set_id (media, str);
external_url = g_strdup_printf ("https://vimeo.com/%s", str);
grl_media_set_external_url (media, external_url);
g_free (external_url);
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_TITLE);
if (str)
{
grl_media_set_title (media, str);
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_DESCRIPTION);
if (str)
{
grl_media_set_description (media, str);
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_DURATION);
if (str)
{
grl_media_set_duration (media, str_to_gint (str));
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_OWNER_NAME);
if (str)
{
grl_media_set_author (media, str);
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_UPLOAD_DATE);
if (str)
{
GDateTime *date = parse_date (str);
if (date) {
grl_media_set_publication_date (media, date);
g_date_time_unref (date);
}
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_THUMBNAIL);
if (str)
{
grl_media_set_thumbnail (media, str);
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_WIDTH);
if (str)
{
grl_media_set_width (media, str_to_gint (str));
}
str = g_hash_table_lookup (video, VIMEO_VIDEO_HEIGHT);
if (str)
{
grl_media_set_height (media, str_to_gint (str));
}
}
static void
tracker_evt_update_orphan_item_cb (GObject *object,
GAsyncResult *result,
tracker_evt_update_t *evt)
{
guint id;
const gchar *type, *datasource;
GrlTrackerSource *source = NULL;
GError *error = NULL;
GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);
if (!tracker_sparql_cursor_next_finish (evt->cursor, result, &error)) {
if (error != NULL) {
GRL_DEBUG ("\terror in parsing : %s", error->message);
g_error_free (error);
} else {
GRL_DEBUG ("\tend of parsing...");
}
g_clear_object (&evt->cursor);
if (grl_tracker_per_device_source) {
/* Once all items have been processed, add new sources and we're
done. */
tracker_evt_postupdate_sources (evt);
} else {
tracker_evt_update_free (evt);
}
return;
}
type = tracker_sparql_cursor_get_string (evt->cursor, 0, NULL);
id = tracker_sparql_cursor_get_integer (evt->cursor, 1);
datasource = tracker_sparql_cursor_get_string (evt->cursor, 2, NULL);
GRL_DEBUG ("\tOrphan item: id=%u datasource=%s", id, datasource);
if (!grl_tracker_per_device_source)
source = grl_tracker_source_find ("");
if (!source && datasource)
source = grl_tracker_source_find (datasource);
if (source && GRL_IS_TRACKER_SOURCE (source)) {
GrlMedia *media;
GRL_DEBUG (" \tAdding to cache id=%u", id);
grl_tracker_source_cache_add_item (grl_tracker_item_cache, id, source);
if (grl_tracker_source_can_notify (source)) {
media = grl_tracker_build_grilo_media (type);
if (media) {
gchar *str_id = g_strdup_printf ("%i", id);
gint change_type =
GPOINTER_TO_INT (g_hash_table_lookup (evt->orphan_items,
GSIZE_TO_POINTER (id)));
grl_media_set_id (media, str_id);
g_free (str_id);
GRL_DEBUG ("\tNotify id=%u source=%s p=%p", id,
grl_source_get_name (GRL_SOURCE (source)),
source);
grl_source_notify_change (GRL_SOURCE (source),
media, change_type, FALSE);
g_object_unref (media);
}
}
}
tracker_sparql_cursor_next_async (evt->cursor, NULL,
(GAsyncReadyCallback) tracker_evt_update_orphan_item_cb,
(gpointer) evt);
}
