static void
source_browser (gpointer data,
gpointer user_data)
{
GrlSource *source = GRL_SOURCE (data);
GrlMedia *media = GRL_MEDIA (user_data);
GList *media_elements;
GError *error = NULL;
GList *keys;
GrlOperationOptions *options = NULL;
GrlCaps *caps;
keys = grl_metadata_key_list_new (GRL_METADATA_KEY_TITLE,
GRL_METADATA_KEY_URL,
GRL_METADATA_KEY_MODIFICATION_DATE,
GRL_METADATA_KEY_MIME,
GRL_METADATA_KEY_CHILDCOUNT,
NULL);
g_debug ("Detected new source available: '%s'",
grl_source_get_name (source));
if (!(grl_source_supported_operations (source) & GRL_OP_BROWSE))
goto out;
g_debug ("Browsing source: %s", grl_source_get_name (source));
/* Here is how you can browse a source, you have to provide:
1) The source you want to browse contents from.
2) The container object you want to browse (NULL for the root container)
3) A list of metadata keys we are interested in.
4) Options to control certain aspects of the browse operation.
5) A callback that the framework will invoke for each available result
6) User data for the callback
It returns an operation identifier that you can use to match results
with the corresponding request (we ignore it here) */
caps = grl_source_get_caps (source, GRL_OP_BROWSE);
options = grl_operation_options_new (caps);
grl_operation_options_set_count (options, BROWSE_CHUNK_SIZE);
grl_operation_options_set_resolution_flags (options, GRL_RESOLVE_IDLE_RELAY);
media_elements = grl_pls_browse_sync (GRL_SOURCE (source),
media, keys,
options,
NULL,
&error);
if (!media_elements) {
g_debug ("No elements found for source: %s!",
grl_source_get_name (source));
goto out;
}
if (error)
g_error ("Failed to browse source: %s", error->message);
g_list_foreach (media_elements, element_browser, source);
out:
g_list_free (keys);
g_clear_object (&options);
}
static void
load_plugins (gchar* playlist)
{
GrlRegistry *registry;
GrlSource *source;
GError *error = NULL;
GList *keys;
GrlOperationOptions *options;
GrlCaps *caps;
GrlMedia* media;
gboolean pls_media;
const gchar *mime;
registry = grl_registry_get_default ();
grl_registry_load_all_plugins (registry, FALSE, NULL);
/* Activate plugin */
if (!grl_registry_activate_plugin_by_id (registry, "grl-filesystem", &error))
g_error ("Failed to load plugin: %s", error->message);
source = grl_registry_lookup_source (registry, "grl-filesystem");
if (!source)
g_error ("Unable to load grl-filesystem plugin");
if (!(grl_source_supported_operations (source) & GRL_OP_MEDIA_FROM_URI))
g_error ("Unable to get media from URI");
keys = grl_metadata_key_list_new (GRL_METADATA_KEY_TITLE, GRL_METADATA_KEY_URL, GRL_METADATA_KEY_MIME, NULL);
if (!keys)
g_error ("Unable to create key list");
caps = grl_source_get_caps (source, GRL_OP_MEDIA_FROM_URI);
if (!caps)
g_error ("Unable to get source caps");
options = grl_operation_options_new (caps);
if (!options)
g_error ("Unable to create operation options");
media = grl_source_get_media_from_uri_sync (source, playlist, keys, options, &error);
if (!media)
g_error ("Unable to get GrlMedia for playlist %s", playlist);
g_object_unref (options);
mime = grl_media_get_mime (media);
pls_media = grl_pls_media_is_playlist (media);
g_printf("Got Media for %s - mime=%s\n", playlist, mime);
g_printf("\tgrl_pls_media_is_playlist = %d\n", pls_media);
if (pls_media) {
source_browser (source, media);
}
g_object_unref (media);
g_object_unref (source);
}
static GrlOperationOptions *
get_grl_options (GrlSource *source)
{
GrlCaps *caps;
GrlOperationOptions *opts = NULL;
caps = grl_source_get_caps (source, GRL_OP_BROWSE);
opts = grl_operation_options_new (caps);
g_return_val_if_fail (opts != NULL, NULL);
grl_operation_options_set_flags (opts, GRL_RESOLVE_FAST_ONLY);
return opts;
}
static GrlOperationOptions *
make_operation_options (RBGriloSource *source, GrlSupportedOps op, int position)
{
GrlOperationOptions *options;
GrlCaps *caps;
caps = grl_source_get_caps (source->priv->grilo_source, op);
options = grl_operation_options_new (caps);
grl_operation_options_set_skip (options, position);
grl_operation_options_set_count (options,
CONTAINER_FETCH_SIZE);
grl_operation_options_set_type_filter (options, GRL_TYPE_FILTER_AUDIO);
grl_operation_options_set_flags (options, GRL_RESOLVE_NORMAL);
return options;
}
static struct MultipleSearchData *
start_multiple_search_operation (guint search_id,
const GList *sources,
const gchar *text,
const GList *keys,
const GList *skip_counts,
gint count,
GrlOperationOptions *options,
GrlSourceResultCb user_callback,
gpointer user_data)
{
GRL_DEBUG ("start_multiple_search_operation");
struct MultipleSearchData *msd;
GList *iter_sources, *iter_skips;
guint n;
gint first_count, individual_count;
/* Prepare data required to execute the operation */
msd = g_new0 (struct MultipleSearchData, 1);
msd->table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, g_free);
msd->remaining =
(count == GRL_COUNT_INFINITY) ? GRL_COUNT_INFINITY : (count - 1);
msd->search_id = search_id;
msd->text = g_strdup (text);
msd->keys = g_list_copy ((GList *) keys);
msd->options = g_object_ref (options);
msd->user_callback = user_callback;
msd->user_data = user_data;
/* Compute the # of items to request by each source */
n = g_list_length ((GList *) sources);
if (count == GRL_COUNT_INFINITY) {
individual_count = GRL_COUNT_INFINITY;
first_count = GRL_COUNT_INFINITY;
} else {
individual_count = count / n;
first_count = individual_count + count % n;
}
/* Issue search operations on each source */
iter_sources = (GList *) sources;
iter_skips = (GList *) skip_counts;
n = 0;
while (iter_sources) {
GrlSource *source;
guint c, id;
struct ResultCount *rc;
guint skip;
source = GRL_SOURCE (iter_sources->data);
/* c is the count to use for this source */
c = (n == 0) ? first_count : individual_count;
n++;
/* Only interested in sources with c != 0 */
if (c != 0) {
GrlOperationOptions *source_options = NULL;
GrlCaps *source_caps;
/* We use ResultCount to keep track of results emitted by this source */
rc = g_new0 (struct ResultCount, 1);
rc->count = c;
g_hash_table_insert (msd->table, source, rc);
/* Check if we have to apply a "skip" parameter to this source
(useful when we are chaining queries to complete the result count) */
if (iter_skips) {
skip = GPOINTER_TO_INT (iter_skips->data);
} else {
skip = 0;
}
source_caps = grl_source_get_caps (source, GRL_OP_SEARCH);
grl_operation_options_obey_caps (options, source_caps, &source_options, NULL);
grl_operation_options_set_skip (source_options, skip);
grl_operation_options_set_count (source_options, rc->count);
/* Execute the search on this source */
id = grl_source_search (source,
msd->text,
msd->keys,
source_options,
multiple_search_cb,
msd);
GRL_DEBUG ("Operation %s:%u: Searching %u items from offset %u",
grl_source_get_name (GRL_SOURCE (source)),
id, rc->count, skip);
g_object_unref (source_options);
/* Keep track of this operation and this source */
msd->search_ids = g_list_prepend (msd->search_ids, GINT_TO_POINTER (id));
msd->sources = g_list_prepend (msd->sources, source);
msd->sources_count++;
}
/* Move to the next source */
iter_sources = g_list_next (iter_sources);
iter_skips = g_list_next (iter_skips);
}
int main (int argc, char *argv[])
{
#if !GLIB_CHECK_VERSION(2,35,0)
g_type_init ();
#endif
grl_init (&argc, &argv);
/*
* Set the TMDB API key:
* You must use your own TMDB API key in your own application.
*/
GrlRegistry *reg = grl_registry_get_default ();
GrlConfig *config = grl_config_new (TMDB_PLUGIN_ID, NULL);
grl_config_set_api_key (config, TMDB_KEY);
grl_registry_add_config (reg, config, NULL);
/*
* Get the plugin:
*/
GError *error = NULL;
gboolean plugin_loaded =
grl_registry_load_plugin_by_id (reg, TMDB_PLUGIN_ID, &error);
g_assert (plugin_loaded);
g_assert_no_error (error);
/*
* Get the Grilo source:
*/
GrlSource *src =
grl_registry_lookup_source (reg, TMDB_PLUGIN_ID);
/*
* Check that it has the expected capability:
*/
g_assert (grl_source_supported_operations (src) & GRL_OP_RESOLVE);
GrlCaps *caps = grl_source_get_caps (src, GRL_OP_RESOLVE);
g_assert (caps);
GrlOperationOptions *options = grl_operation_options_new (caps);
/*
* A media item that we will give to the TMDB plugin,
* to discover its details.
*/
GrlMedia *media = grl_media_video_new ();
grl_media_set_title (media, "Sherlock Holmes");
/*
* Discover what keys are provided by the source:
*/
const GList *keys = grl_source_supported_keys (src);
const GList* l = NULL;
for (l = keys; l != NULL; l = l->next) {
GrlKeyID id = GPOINTER_TO_INT (l->data);
g_assert (id);
const gchar *name = grl_metadata_key_get_name (id);
printf ("Supported key: %s\n", name);
/*
* Remember this for later use:
* You may instead use grl_registry_lookup_metadata_key_name().
*/
if (g_strcmp0 (name, "tmdb-director") == 0) {
director_key = id;
}
}
/*
* Ask the TMDB plugin for the media item's details,
* from the TMDB online service:
*/
grl_source_resolve (src, media,
keys, options,
resolve_cb, NULL);
/*
* Start the main loop so our callback can be called:
*/
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
/*
* Release objects:
*/
g_object_unref (media);
g_object_unref (config);
g_object_unref (options);
/*
* Deinitialize Grilo:
*/
grl_deinit ();
}
