static void
parsed_finished (TotemPlParser *pl, GAsyncResult *result, BrowseData *data)
{
TotemPlParserResult retval;
GError *error = NULL;
retval = totem_pl_parser_parse_finish (TOTEM_PL_PARSER (pl), result, &error);
/* Do the fallback ourselves */
if (retval == TOTEM_PL_PARSER_RESULT_IGNORED) {
grl_media_set_url (data->media, grl_media_get_id (data->media));
retval = TOTEM_PL_PARSER_RESULT_SUCCESS;
}
if (retval == TOTEM_PL_PARSER_RESULT_SUCCESS &&
grl_media_get_url (data->media) != NULL) {
data->bs->callback (data->bs->source,
data->bs->operation_id,
data->media,
-1,
data->bs->user_data,
NULL);
} else {
if (retval == TOTEM_PL_PARSER_RESULT_ERROR) {
GRL_WARNING ("Failed to parse '%s': %s",
grl_media_get_id (data->media),
error->message);
g_error_free (error);
}
g_object_unref (data->media);
}
data->media = NULL;
resolve_disc_urls (data);
}
static void
grl_raitv_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
RaitvOperation *op = g_slice_new0 (RaitvOperation);
const gchar *container_id;
GRL_DEBUG ("%s: %s", __FUNCTION__, grl_media_get_id (bs->container));
container_id = grl_media_get_id (bs->container);
op->source = g_object_ref (source);
op->cancellable = g_cancellable_new ();
op->length = grl_operation_options_get_count (bs->options);
op->operation_id = bs->operation_id;
op->container_id = container_id;
op->callback = bs->callback;
op->user_data = bs->user_data;
op->skip = grl_operation_options_get_skip (bs->options);
op->count = op->length;
op->offset = 0;
grl_operation_set_data_full (bs->operation_id, op, (GDestroyNotify) raitv_operation_free);
RaitvMediaType type = classify_media_id (container_id);
switch (type)
{
case RAITV_MEDIA_TYPE_ROOT:
produce_from_directory (root_dir, root_dir_size, op, type);
break;
case RAITV_MEDIA_TYPE_POPULARS:
produce_from_directory (themes_dir,
root_dir[ROOT_DIR_POPULARS_INDEX].count, op, RAITV_MEDIA_TYPE_POPULAR_THEME);
break;
case RAITV_MEDIA_TYPE_RECENTS:
produce_from_directory (themes_dir,
root_dir[ROOT_DIR_RECENTS_INDEX].count, op, RAITV_MEDIA_TYPE_RECENT_THEME);
break;
case RAITV_MEDIA_TYPE_POPULAR_THEME:
produce_from_popular_theme (op);
break;
case RAITV_MEDIA_TYPE_RECENT_THEME:
produce_from_recent_theme (op);
break;
case RAITV_MEDIA_TYPE_VIDEO:
default:
g_assert_not_reached ();
break;
}
}
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
on_g_volume_monitor_added_event (GVolumeMonitor *monitor,
GMount *mount,
GrlOpticalMediaSource *source)
{
GrlMedia **media;
TotemPlParser *pl;
if (ignore_mount (mount))
return;
media = (GrlMedia **) g_new0 (gpointer, 1);
*media = create_media_from_mount (mount);
if (*media == NULL) {
g_free (media);
return;
}
pl = totem_pl_parser_new ();
g_object_set_data (G_OBJECT (pl), "media", media);
g_object_set (pl, "recurse", FALSE, NULL);
g_signal_connect (G_OBJECT (pl), "entry-parsed",
G_CALLBACK (entry_parsed_cb), media);
totem_pl_parser_parse_async (pl,
grl_media_get_id (*media),
FALSE,
source->priv->cancellable,
(GAsyncReadyCallback) parsed_finished_item,
source);
}
static gboolean
account_miner_job_process_entry (GomAccountMinerJob *job,
OpType op_type,
FlickrEntry *entry,
GError **error)
{
GDateTime *created_time, *modification_date;
gchar *contact_resource;
gchar *mime;
gchar *resource = NULL;
gchar *date, *identifier;
const gchar *class = NULL, *id;
const gchar *url;
gboolean resource_exists, mtime_changed;
gint64 new_mtime;
if (op_type == OP_CREATE_HIEARCHY && entry->parent == NULL && !GRL_IS_MEDIA_BOX (entry->media))
return TRUE;
id = grl_media_get_id (entry->media);
identifier = g_strdup_printf ("%sflickr:%s",
GRL_IS_MEDIA_BOX (entry->media) ?
"photos:collection:" : "",
id);
/* remove from the list of the previous resources */
g_hash_table_remove (job->previous_resources, identifier);
if (GRL_IS_MEDIA_BOX (entry->media))
class = "nfo:DataContainer";
else
static void
resolve_disc_urls (BrowseData *data)
{
g_assert (data->media == NULL);
if (data->media_list == NULL ||
g_cancellable_is_cancelled (data->cancellable)) {
/* If we got cancelled, there's still some media
* to resolve here */
if (data->media_list) {
g_list_free_full (data->media_list, g_object_unref);
}
/* No media left, we're done */
data->bs->callback (data->bs->source,
data->bs->operation_id,
NULL,
0,
data->bs->user_data,
NULL);
g_object_unref (data->cancellable);
g_object_unref (data->parser);
g_free (data);
return;
}
data->media = data->media_list->data;
data->media_list = g_list_delete_link (data->media_list, data->media_list);
totem_pl_parser_parse_async (data->parser,
grl_media_get_id (data->media),
FALSE,
data->cancellable,
(GAsyncReadyCallback) parsed_finished,
data);
}
static void
grl_bookmarks_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GRL_DEBUG ("grl_bookmarks_source_browse");
OperationSpec *os;
GrlBookmarksSource *bookmarks_source;
GError *error = NULL;
bookmarks_source = GRL_BOOKMARKS_SOURCE (source);
if (!bookmarks_source->priv->adapter) {
GRL_WARNING ("Can't execute operation: no database connection.");
error = g_error_new_literal (GRL_CORE_ERROR,
GRL_CORE_ERROR_BROWSE_FAILED,
_("No database connection"));
bs->callback (bs->source, bs->operation_id, NULL, 0, bs->user_data, error);
g_error_free (error);
}
/* Configure browse operation */
os = g_slice_new0 (OperationSpec);
os->source = bs->source;
os->operation_id = bs->operation_id;
os->media_id = grl_media_get_id (bs->container);
os->count = grl_operation_options_get_count (bs->options);
os->skip = grl_operation_options_get_skip (bs->options);
os->type_filter = grl_operation_options_get_type_filter (bs->options);
os->callback = bs->callback;
os->user_data = bs->user_data;
os->error_code = GRL_CORE_ERROR_BROWSE_FAILED;
produce_bookmarks_from_category (os, os->media_id ? os->media_id : "0");
}
static void
grl_vimeo_source_resolve (GrlSource *source,
GrlSourceResolveSpec *rs)
{
gint id;
const gchar *id_str;
if (!rs->media || (id_str = grl_media_get_id (rs->media)) == NULL) {
goto send_unchanged;
}
/* As all the keys are added always, except URL, the only case is missing URL */
if (g_list_find (rs->keys, GRLKEYID_TO_POINTER (GRL_METADATA_KEY_URL)) != NULL &&
grl_media_get_url (rs->media) == NULL) {
errno = 0;
id = (gint) g_ascii_strtod (id_str, NULL);
if (errno != 0) {
goto send_unchanged;
}
g_vimeo_video_get_play_url (GRL_VIMEO_SOURCE (source)->priv->vimeo,
id,
video_get_play_url_cb,
rs);
} else {
goto send_unchanged;
}
return;
send_unchanged:
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
}
static void
parsed_finished (TotemPlParser *pl, GAsyncResult *result, BrowseData *data)
{
TotemPlParserResult retval;
GError *error = NULL;
retval = totem_pl_parser_parse_finish (TOTEM_PL_PARSER (pl), result, &error);
/* Do the fallback ourselves */
if (retval == TOTEM_PL_PARSER_RESULT_IGNORED) {
GRL_DEBUG ("%s: Falling back for %s as has it's been ignored", __FUNCTION__,
grl_media_get_id (data->media));
grl_media_set_url (data->media, grl_media_get_id (data->media));
retval = TOTEM_PL_PARSER_RESULT_SUCCESS;
}
if (retval == TOTEM_PL_PARSER_RESULT_SUCCESS &&
grl_media_get_url (data->media) != NULL) {
GrlOpticalMediaSource *source;
source = GRL_OPTICAL_MEDIA_SOURCE (data->bs->source);
GRL_DEBUG ("%s: Adding %s which resolved to %s", __FUNCTION__,
grl_media_get_id (data->media),
grl_media_get_url (data->media));
data->bs->callback (GRL_SOURCE (source),
data->bs->operation_id,
data->media,
-1,
data->bs->user_data,
NULL);
source->priv->list = g_list_append (source->priv->list, g_object_ref (data->media));
} else {
if (retval == TOTEM_PL_PARSER_RESULT_ERROR ||
retval == TOTEM_PL_PARSER_RESULT_CANCELLED) {
GRL_WARNING ("Failed to parse '%s': %s",
grl_media_get_id (data->media),
error ? error->message : "No reason");
g_error_free (error);
}
g_object_unref (data->media);
}
data->media = NULL;
resolve_disc_urls (data);
}
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 gchar *
mex_grilo_program_get_id (MexProgram *program)
{
MexGriloProgram *self = MEX_GRILO_PROGRAM (program);
MexGriloProgramPrivate *priv = self->priv;
const gchar *id = grl_media_get_id (priv->media);
if (!id)
return NULL;
return g_strdup (id);
}
static void
bookmark_resolve (GrlSourceResolveSpec *rs)
{
GomRepository *repository;
GValue value = { 0, };
GomFilter *filter;
GomResource *resource;
GError *error = NULL;
gint64 id;
GrlTypeFilter type_filter;
GRL_DEBUG (__FUNCTION__);
repository = GRL_BOOKMARKS_SOURCE (rs->source)->priv->repository;
id = g_ascii_strtoll (grl_media_get_id (rs->media), NULL, 0);
if (!id) {
/* Root category: special case */
grl_media_set_title (rs->media, GRL_ROOT_TITLE);
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
return;
}
g_value_init (&value, G_TYPE_INT64);
g_value_set_int64 (&value, id);
filter = gom_filter_new_eq (BOOKMARKS_TYPE_RESOURCE, "id", &value);
g_value_unset (&value);
resource = gom_repository_find_one_sync (repository,
BOOKMARKS_TYPE_RESOURCE,
filter,
&error);
g_object_unref (filter);
if (!resource) {
GRL_WARNING ("Failed to get bookmark: %s", error->message);
g_error_free (error);
error = g_error_new_literal (GRL_CORE_ERROR,
GRL_CORE_ERROR_RESOLVE_FAILED,
_("Failed to get bookmark metadata"));
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, error);
g_error_free (error);
return;
}
type_filter = grl_operation_options_get_type_filter (rs->options);
build_media_from_resource (rs->media, resource, type_filter);
g_object_unref (resource);
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
}
static gint
find_mount (gconstpointer a,
gconstpointer b)
{
GrlMedia *media = (GrlMedia *) a;
GMount *mount = (GMount *) b;
char *id;
gint ret;
id = create_mount_id (mount);
ret = g_strcmp0 (id, grl_media_get_id (media));
g_free (id);
return ret;
}
static void
entry_parsed_cb (TotemPlParser *parser,
const char *uri,
GHashTable *metadata,
BrowseData *data)
{
g_return_if_fail (data->media != NULL);
if (grl_media_get_url (data->media) != NULL) {
GRL_WARNING ("Was going to set media '%s' to URL '%s' but already has URL '%s'",
grl_media_get_id (data->media),
uri,
grl_media_get_url (data->media));
return;
}
grl_media_set_url (data->media, uri);
}
static void
_mex_grilo_feed_content_updated (GrlSource *source,
GPtrArray *changed_medias,
GrlSourceChangeType change_type,
gboolean known_location,
MexGriloFeed *feed)
{
gint i;
GrlMedia *media;
const gchar *id;
MexGriloProgram *program;
for (i = 0 ; i < changed_medias->len ; i++)
{
media = g_ptr_array_index (changed_medias, i);
id = grl_media_get_id (media);
switch (change_type)
{
case GRL_CONTENT_CHANGED:
program = MEX_GRILO_PROGRAM (mex_feed_lookup (MEX_FEED (feed), id));
/* The policy might be slightly different here... */
if (program != NULL) {
mex_grilo_program_set_grilo_media (program, media);
}
break;
case GRL_CONTENT_ADDED:
program = MEX_GRILO_PROGRAM (mex_feed_lookup (MEX_FEED (feed), id));
if (program != NULL) {
mex_grilo_program_set_grilo_media (program, media);
} else {
emit_media_added (feed, media);
}
break;
case GRL_CONTENT_REMOVED:
program = MEX_GRILO_PROGRAM (mex_feed_lookup (MEX_FEED (feed), id));
if (program != NULL) {
mex_model_remove_content (MEX_MODEL (feed), MEX_CONTENT (program));
}
break;
}
}
}
static void
grl_metadata_store_source_resolve (GrlSource *source,
GrlSourceResolveSpec *rs)
{
const gchar *source_id, *media_id;
sqlite3_stmt *stmt;
GError *error = NULL;
GRL_DEBUG (__FUNCTION__);
source_id = grl_media_get_source (rs->media);
media_id = grl_media_get_id (rs->media);
/* We need the source id */
if (!source_id) {
GRL_WARNING ("Failed to resolve metadata: source-id not available");
error = g_error_new (GRL_CORE_ERROR,
GRL_CORE_ERROR_RESOLVE_FAILED,
_("Failed to resolve: %s"),
_("\"source-id\" not available"));
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, error);
g_error_free (error);
return;
}
/* Special case for root categories */
if (!media_id) {
media_id = "";
}
stmt = query_metadata_store (GRL_METADATA_STORE_SOURCE (source)->priv->db,
source_id, media_id);
if (stmt) {
fill_metadata (rs->media, rs->keys, stmt);
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
} else {
GRL_WARNING ("Failed to resolve metadata");
error = g_error_new_literal (GRL_CORE_ERROR,
GRL_CORE_ERROR_RESOLVE_FAILED,
_("Failed to resolve"));
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, error);
g_error_free (error);
}
}
static void
entry_parsed_cb (TotemPlParser *parser,
const char *uri,
GHashTable *metadata,
GrlMedia **media)
{
char *scheme;
g_return_if_fail (*media != NULL);
if (grl_media_get_url (*media) != NULL) {
GRL_WARNING ("Was going to set media '%s' to URL '%s' but already has URL '%s'",
grl_media_get_id (*media),
uri,
grl_media_get_url (*media));
return;
}
scheme = g_uri_parse_scheme (uri);
if (scheme != NULL && !g_str_equal (scheme, "file"))
grl_media_set_url (*media, uri);
g_free (scheme);
}
static gchar *
serialize_media (GrlMedia *media)
{
static GList *serialize_keys = NULL;
const gchar *media_id;
if (!serialize_keys) {
serialize_keys =
grl_metadata_key_list_new (GRL_METADATA_KEY_GRILO_MS2_PARENT,
NULL);
}
media_id = grl_media_get_id (media);
/* Check if it is root media */
if (!media_id) {
return g_strdup (MS2_ROOT);
} else {
return grl_media_serialize_extended (media,
GRL_MEDIA_SERIALIZE_PARTIAL,
serialize_keys);
}
}
static void
resolve_cb (GrlSource *source,
guint operation_id,
GrlMedia *media,
gpointer user_data,
const GError *error)
{
GriloMs2Data *grdata = (GriloMs2Data *) user_data;
if (error) {
grdata->error = g_error_copy (error);
grdata->updated = TRUE;
return;
}
/* Special case: for root media, if there is no title use the source's name */
if (grl_media_get_id (media) == NULL &&
!grl_data_has_key (GRL_DATA (media), GRL_METADATA_KEY_TITLE)) {
grl_media_set_title (media,
grl_source_get_name (source));
}
grdata->properties = ms2_server_new_properties_hashtable ();
fill_properties_table (grdata->server,
grdata->properties,
grdata->keys,
media);
fill_other_properties_table (grdata->server,
source,
grdata->properties,
grdata->other_keys,
media);
grdata->updated = TRUE;
}
static void
grl_metadata_store_source_store_metadata (GrlSource *source,
GrlSourceStoreMetadataSpec *sms)
{
GRL_DEBUG ("grl_metadata_store_source_set_metadata");
const gchar *media_id, *source_id;
GError *error = NULL;
GList *failed_keys = NULL;
source_id = grl_media_get_source (sms->media);
media_id = grl_media_get_id (sms->media);
/* We need the source id */
if (!source_id) {
GRL_WARNING ("Failed to update metadata: source-id not available");
error = g_error_new (GRL_CORE_ERROR,
GRL_CORE_ERROR_STORE_METADATA_FAILED,
_("Failed to update metadata: %s"),
_("\"source-id\" not available"));
failed_keys = g_list_copy (sms->keys);
} else {
/* Special case for root categories */
if (!media_id) {
media_id = "";
}
failed_keys = write_keys (GRL_METADATA_STORE_SOURCE (source)->priv->db,
source_id, media_id, sms, &error);
}
sms->callback (sms->source, sms->media, failed_keys, sms->user_data, error);
g_clear_error (&error);
g_list_free (failed_keys);
}
static void
search_cb (GVimeo *vimeo, GList *video_list, gpointer user_data)
{
GrlMedia *media = NULL;
AddMediaUrlData *amud;
SearchData *sd = (SearchData *) user_data;
gint count = grl_operation_options_get_count (sd->ss->options);
gint id;
gchar *media_type;
gint video_list_size;
/* Go to offset element */
video_list = g_list_nth (video_list, sd->offset);
/* No more elements can be sent */
if (!video_list) {
sd->ss->callback (sd->ss->source,
sd->ss->operation_id,
NULL,
0,
sd->ss->user_data,
NULL);
g_slice_free (SearchData, sd);
return;
}
video_list_size = g_list_length (video_list);
if (count > video_list_size) {
count = video_list_size;
}
if (sd->get_url) {
sd->queue = g_queue_new ();
}
while (video_list && count)
{
media_type = g_hash_table_lookup (video_list->data, "title");
if (media_type) {
media = grl_media_video_new ();
} else {
media = NULL;
}
if (media)
{
update_media (media, video_list->data);
if (sd->get_url) {
amud = g_slice_new (AddMediaUrlData);
amud->computed = FALSE;
amud->media = media;
amud->index = --count;
amud->sd = sd;
g_queue_push_head (sd->queue, amud);
id = (gint) g_ascii_strtod (grl_media_get_id (media), NULL);
g_vimeo_video_get_play_url (sd->vimeo,
id,
add_url_media_cb,
amud);
} else {
sd->ss->callback (sd->ss->source,
sd->ss->operation_id,
media,
--count,
sd->ss->user_data,
NULL);
}
}
video_list = g_list_next (video_list);
}
if (!sd->get_url) {
g_slice_free (SearchData, sd);
}
}
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 void
browse_cb (GrlSource *source,
guint browse_id,
GrlMedia *media,
guint remaining,
gpointer userdata,
const GError *error)
{
MexGriloFeed *feed = (MexGriloFeed *) userdata;
MexGriloFeedPrivate *priv = feed->priv;
MexGriloProgram *program;
if (error) {
g_warning ("Error browsing: %s", error->message);
return;
}
if (priv->op == NULL) {
g_warning ("No operation found");
return;
}
if (priv->op->op_id != browse_id)
return;
if (media) {
/*
* FIXME: talk to thomas/lionel/grilo guys about that crasher. We are
* being called with what seems to be an invalid media when cancelled.
* this is obviously temporary to enable people to work in the meantime
*/
gconstpointer foo = grl_media_get_id (media);
if (!foo) {
const gchar *source_name;
source_name =
grl_source_get_name (GRL_SOURCE (priv->source));
g_warning ("FIXME: oh no, a grilo bug! (on the '%s' source)",
source_name);
return;
}
program = MEX_GRILO_PROGRAM (mex_feed_lookup (MEX_FEED (feed),
grl_media_get_id (media)));
if (program != NULL) {
mex_grilo_program_set_grilo_media (program, media);
return;
} else {
emit_media_added (feed, media);
g_object_unref (media);
}
}
priv->op->count++;
if (remaining == 0) {
priv->op->op_id = 0;
/* Emit completed signal */
priv->completed = TRUE;
g_object_notify (G_OBJECT (feed), "completed");
}
}
static void
fill_properties_table (MS2Server *server,
GHashTable *properties_table,
GList *keys,
GrlMedia *media)
{
GList *prop;
GrlKeyID key;
const gchar *title;
gchar *id;
gchar *urls[2] = { 0 };
for (prop = keys; prop; prop = g_list_next (prop)) {
key = GRLPOINTER_TO_KEYID (prop->data);
if (key == GRL_METADATA_KEY_ID ||
grl_data_has_key (GRL_DATA (media), key)) {
if (key == GRL_METADATA_KEY_ID) {
id = serialize_media (media);
if (id) {
ms2_server_set_path (server,
properties_table,
id,
grl_media_is_container (media));
g_free (id);
}
} else if (key == GRL_METADATA_KEY_TITLE) {
/* Ensure we always insert a valid title */
title = grl_media_get_title (media);
if (!title) {
title = "Unknown";
}
ms2_server_set_display_name (server,
properties_table,
title);
} else if (key == GRL_METADATA_KEY_ALBUM) {
ms2_server_set_album (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_ALBUM));
} else if (key == GRL_METADATA_KEY_ARTIST) {
ms2_server_set_artist (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_ARTIST));
} else if (key == GRL_METADATA_KEY_GENRE) {
ms2_server_set_genre (server,
properties_table,
grl_data_get_string (GRL_DATA (media),
GRL_METADATA_KEY_GENRE));
} else if (key == GRL_METADATA_KEY_MIME) {
ms2_server_set_mime_type (server,
properties_table,
grl_media_get_mime (media));
} else if (key == GRL_METADATA_KEY_URL) {
urls[0] = (gchar *) grl_media_get_url (media);
ms2_server_set_urls (server, properties_table, urls);
} else if (key == GRL_METADATA_KEY_BITRATE) {
ms2_server_set_bitrate (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_BITRATE));
} else if (key == GRL_METADATA_KEY_DURATION) {
ms2_server_set_duration (server,
properties_table,
grl_media_get_duration (media));
} else if (key == GRL_METADATA_KEY_HEIGHT) {
ms2_server_set_height (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_HEIGHT));
} else if (key == GRL_METADATA_KEY_WIDTH) {
ms2_server_set_width (server,
properties_table,
grl_data_get_int (GRL_DATA (media),
GRL_METADATA_KEY_WIDTH));
} else if (key == GRL_METADATA_KEY_GRILO_MS2_PARENT) {
if (grl_media_get_id (media) == NULL) {
ms2_server_set_parent (server,
properties_table,
MS2_ROOT);
} else {
ms2_server_set_parent (server,
properties_table,
grl_media_get_grilo_ms2_parent (media));
}
}
}
}
}
static void
fill_other_properties_table (MS2Server *server,
GrlSource *source,
GHashTable *properties_table,
GList *keys,
GrlMedia *media)
{
GList *key;
gint childcount;
/* Compute childcount */
if (grl_media_is_container (media)) {
childcount = grl_media_get_childcount (media);
if (childcount == GRL_METADATA_KEY_CHILDCOUNT_UNKNOWN) {
childcount = G_MAXINT;
}
} else {
childcount = 0;
}
for (key = keys; key; key = g_list_next (key)) {
if (g_strcmp0 (key->data, MS2_PROP_TYPE) == 0) {
if (grl_media_is_container (media)) {
ms2_server_set_item_type (server,
properties_table,
MS2_ITEM_TYPE_CONTAINER);
} else if (grl_media_is_image (media)) {
ms2_server_set_item_type (server,
properties_table,
MS2_ITEM_TYPE_IMAGE);
} else if (grl_media_is_audio (media)) {
ms2_server_set_item_type (server,
properties_table,
MS2_ITEM_TYPE_AUDIO);
} else if (grl_media_is_video (media)) {
ms2_server_set_item_type (server,
properties_table,
MS2_ITEM_TYPE_VIDEO);
} else {
ms2_server_set_item_type (server,
properties_table,
MS2_ITEM_TYPE_UNKNOWN);
}
} else if (g_strcmp0 (key->data, MS2_PROP_CHILD_COUNT) == 0) {
ms2_server_set_child_count (server, properties_table, childcount);
} else if (g_strcmp0 (key->data, MS2_PROP_ITEM_COUNT) == 0) {
ms2_server_set_item_count (server, properties_table, childcount);
} else if (g_strcmp0 (key->data, MS2_PROP_CONTAINER_COUNT) == 0) {
ms2_server_set_container_count (server, properties_table, childcount);
} else if (g_strcmp0 (key->data, MS2_PROP_SEARCHABLE) == 0) {
/* Only supports search in the root level */
if (grl_media_get_id (media) == NULL &&
grl_source_supported_operations (source) & GRL_OP_SEARCH) {
ms2_server_set_searchable (server,
properties_table,
TRUE);
} else {
ms2_server_set_searchable (server,
properties_table,
FALSE);
}
}
}
}
static void
grl_raitv_source_resolve (GrlSource *source,
GrlSourceResolveSpec *rs)
{
gchar *urltarget;
GrlRaitvSource *self = GRL_RAITV_SOURCE (source);
RaitvOperation *op;
RaitvMediaType mediatype;
GRL_DEBUG ("Starting resolve source: url=%s",grl_media_get_url (rs->media));
if (!GRL_IS_MEDIA_VIDEO (rs->media) && !GRL_IS_MEDIA_BOX (rs->media)) {
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
return;
}
mediatype = classify_media_id (grl_media_get_id (rs->media));
switch (mediatype) {
case RAITV_MEDIA_TYPE_ROOT:
rs->media = produce_container_from_directory (rs->media, NULL, 0, mediatype);
break;
case RAITV_MEDIA_TYPE_POPULARS:
rs->media = produce_container_from_directory (rs->media, root_dir, ROOT_DIR_POPULARS_INDEX, mediatype);
break;
case RAITV_MEDIA_TYPE_RECENTS:
rs->media = produce_container_from_directory (rs->media, root_dir, ROOT_DIR_RECENTS_INDEX, mediatype);
break;
case RAITV_MEDIA_TYPE_POPULAR_THEME:
case RAITV_MEDIA_TYPE_RECENT_THEME:
rs->media = produce_container_from_directory (rs->media,
themes_dir,
get_theme_index_from_id (grl_media_get_id (rs->media)),
mediatype);
break;
case RAITV_MEDIA_TYPE_VIDEO:
op = g_slice_new0 (RaitvOperation);
op->source = g_object_ref (source);
op->cancellable = g_cancellable_new ();
op->operation_id = rs->operation_id;
op->resolveCb = rs->callback;
op->user_data = rs->user_data;
op->media = rs->media;
grl_operation_set_data_full (rs->operation_id, op, (GDestroyNotify) raitv_operation_free);
urltarget = g_strdup_printf ("http://www.rai.tv/dl/RaiTV/programmi/media/%s.html",
grl_media_get_id(rs->media));
GRL_DEBUG ("Opening '%s'", urltarget);
grl_net_wc_request_async (self->priv->wc,
urltarget,
op->cancellable,
proxy_call_resolve_grlnet_async_cb,
op);
g_free(urltarget);
return;
}
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
return;
if ( grl_media_get_url (rs->media) != NULL) {
rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
return;
}
op = g_slice_new0 (RaitvOperation);
op->source = g_object_ref (source);
op->cancellable = g_cancellable_new ();
op->operation_id = rs->operation_id;
op->resolveCb = rs->callback;
op->user_data = rs->user_data;
op->media = rs->media;
grl_operation_set_data_full (rs->operation_id, op, (GDestroyNotify) raitv_operation_free);
urltarget = g_strdup_printf("%s/%s.html","http://www.rai.tv/dl/RaiTV/programmi/media",grl_media_get_id(rs->media));
GRL_DEBUG ("Opening '%s'", urltarget);
grl_net_wc_request_async (self->priv->wc,
urltarget,
op->cancellable,
proxy_call_resolve_grlnet_async_cb,
op);
g_free(urltarget);
}
static RhythmDBEntry *
create_entry_for_media (RhythmDB *db, RhythmDBEntryType *entry_type, GrlData *data, GrlData *container)
{
RhythmDBEntry *entry;
RBGriloEntryData *entry_data;
entry = rhythmdb_entry_lookup_by_location (db, grl_media_get_url (GRL_MEDIA (data)));
if (entry != NULL) {
return entry;
}
rb_debug ("creating entry for %s / %s", grl_media_get_url (GRL_MEDIA (data)), grl_media_get_id (GRL_MEDIA (data)));
entry = rhythmdb_entry_new (db, entry_type, grl_media_get_url (GRL_MEDIA (data))); /* just use the url? */
if (entry == NULL) {
/* crap. */
return NULL;
}
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ALBUM, data, GRL_METADATA_KEY_ALBUM);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ARTIST, data, GRL_METADATA_KEY_ARTIST);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_GENRE, data, GRL_METADATA_KEY_GENRE);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE);
if (grl_data_has_key (data, GRL_METADATA_KEY_PUBLICATION_DATE)) {
/* something - grilo has this as a string? */
}
if (grl_data_has_key (data, GRL_METADATA_KEY_BITRATE)) {
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_BITRATE));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_BITRATE, &v);
g_value_unset (&v);
}
if (grl_data_has_key (data, GRL_METADATA_KEY_DURATION)) {
/* this is probably in seconds */
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_DURATION));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DURATION, &v);
g_value_unset (&v);
}
if (grl_data_has_key (data, GRL_METADATA_KEY_MIME)) {
const char *media_type;
media_type = rb_gst_mime_type_to_media_type (grl_data_get_string (data, GRL_METADATA_KEY_MIME));
if (media_type) {
GValue v = {0,};
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, media_type);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_MEDIA_TYPE, &v);
g_value_unset (&v);
}
}
if (grl_data_has_key (data, GRL_METADATA_KEY_TRACK_NUMBER)) {
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_TRACK_NUMBER));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TRACK_NUMBER, &v);
g_value_unset (&v);
}
/* rating and play count? */
entry_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBGriloEntryData);
entry_data->grilo_data = g_object_ref (data);
if (container != NULL) {
entry_data->grilo_container = g_object_ref (container);
}
/* might want to consider batching this */
rhythmdb_commit (db);
return entry;
}
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);
}
