自学教程：C++ GRL_DEBUG函数代码示例

static voidproduce_from_recent_theme (RaitvOperation *op){  guint category_index;  gchar	*start = NULL;  gchar	*url = NULL;  GrlRaitvSource *source = GRL_RAITV_SOURCE (op->source);  category_index = get_theme_index_from_id (op->container_id);  GRL_DEBUG ("produce_from_recent_theme (container_id=%s, category_index=%d",op->container_id,category_index);  start = g_strdup_printf ("%u", op->offset+op->length);  op->category_info = &themes_dir[category_index];  url = g_strdup_printf (RAITV_VIDEO_RECENT, start, op->category_info->tags, op->category_info->excludeTags);  GRL_DEBUG ("Starting browse request for recent theme (%s)", url);  grl_net_wc_request_async (source->priv->wc,                            url,                            op->cancellable,                            proxy_call_browse_grlnet_async_cb,                            op);  g_free (url);}

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 voidserver_lost_cb (GrlDleynaServersManager *serversmgr,                GrlDleynaServer         *server,                gpointer                *user_data){  GrlDleynaMediaDevice *device;  GrlSource *source;  GrlRegistry *registry;  const gchar* udn;  gchar *source_id;  GRL_DEBUG (G_STRFUNC);  device = grl_dleyna_server_get_media_device (server);  udn = grl_dleyna_media_device_get_udn (device);  GRL_DEBUG ("%s udn: %s ", G_STRFUNC, udn);  registry = grl_registry_get_default ();  source_id = grl_dleyna_source_build_id (udn);  GRL_DEBUG ("%s id: %s ", G_STRFUNC, source_id);  source = grl_registry_lookup_source (registry, source_id);  if (source != NULL) {    GError *error = NULL;    GRL_DEBUG ("%s unregistered %s", G_STRFUNC, source_id);    grl_registry_unregister_source (registry, source, &error);    if (error != NULL) {      GRL_WARNING ("Failed to unregister source %s: %s", udn, error->message);      g_error_free (error);    }  }  g_free (source_id);}

static voidserver_found_cb (GrlDleynaServersManager *serversmgr,                 GrlDleynaServer         *server,                 gpointer                *user_data){  GrlPlugin *plugin = GRL_PLUGIN (user_data);  GrlDleynaMediaDevice *device;  GrlSource *source;  GrlRegistry *registry;  GError *error = NULL;  GRL_DEBUG (G_STRFUNC);  device = grl_dleyna_server_get_media_device (server);  GRL_DEBUG ("%s udn: %s ", G_STRFUNC, grl_dleyna_media_device_get_udn (device));  registry = grl_registry_get_default ();  source = GRL_SOURCE (grl_dleyna_source_new (server));  GRL_DEBUG ("%s id: %s ", G_STRFUNC, grl_source_get_id (source));  grl_registry_register_source (registry, plugin, GRL_SOURCE (source), &error);  if (error != NULL) {    GRL_WARNING ("Failed to register source for DLNA device %s: %s",                 grl_dleyna_media_device_get_udn (device), error->message);    g_error_free (error);  }}

static voidtracker_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 gbooleanignore_drive (GDrive *drive){  GIcon *icon;  if (g_drive_can_eject (drive) == FALSE ||      g_drive_has_media (drive) == FALSE) {    GRL_DEBUG ("%s: Not adding %s as cannot eject or has no media", __FUNCTION__,               g_drive_get_name (drive));    return TRUE;  }  /* Hack to avoid USB devices showing up   * https://bugzilla.gnome.org/show_bug.cgi?id=679624 */  icon = g_drive_get_icon (drive);  if (icon && G_IS_THEMED_ICON (icon)) {    const gchar * const * names;    names = g_themed_icon_get_names (G_THEMED_ICON (icon));    if (names && names[0] && !g_str_has_prefix (names[0], "drive-optical")) {      g_object_unref (icon);      GRL_DEBUG ("%s: Not adding drive %s as is not optical drive", __FUNCTION__,                 g_drive_get_name (drive));      return TRUE;    }  }  g_clear_object (&icon);  return FALSE;}

static voidgrl_metadata_store_source_init (GrlMetadataStoreSource *source){  gint r;  gchar *path;  gchar *db_path;  gchar *sql_error = NULL;  source->priv = GRL_METADATA_STORE_GET_PRIVATE (source);  path = g_strconcat (g_get_user_data_dir (),                      G_DIR_SEPARATOR_S, "grilo-plugins",                      NULL);  if (!g_file_test (path, G_FILE_TEST_IS_DIR)) {    g_mkdir_with_parents (path, 0775);  }  GRL_DEBUG ("Opening database connection...");  db_path = g_strconcat (path, G_DIR_SEPARATOR_S, GRL_SQL_DB, NULL);  r = sqlite3_open (db_path, &source->priv->db);  g_free (path);  if (r) {    g_critical ("Failed to open database '%s': %s",                db_path, sqlite3_errmsg (source->priv->db));    sqlite3_close (source->priv->db);    g_free (db_path);    return;  }  g_free (db_path);  GRL_DEBUG ("  OK");  GRL_DEBUG ("Checking database tables...");  r = sqlite3_exec (source->priv->db, GRL_SQL_CREATE_TABLE_STORE,		    NULL, NULL, &sql_error);  if (r) {    if (sql_error) {      GRL_WARNING ("Failed to create database tables: %s", sql_error);      g_clear_pointer (&sql_error, sqlite3_free);    } else {      GRL_WARNING ("Failed to create database tables.");    }    sqlite3_close (source->priv->db);    return;  }  // For backwards compatibility, add newer columns if they don't exist  // in the old database.  sqlite3_exec (source->priv->db, GRL_SQL_ALTER_TABLE_ADD_FAVOURITE,                NULL, NULL, &sql_error);  sqlite3_exec (source->priv->db, GRL_SQL_ALTER_TABLE_ADD_TYPE_ID,                NULL, NULL, &sql_error);  GRL_DEBUG ("  OK");}

static voidgrl_magnatune_source_init(GrlMagnatuneSource *source){  gint ret;  gchar *path;  gchar *db_path;  gchar *crc_path;  gchar *new_db_path;  gchar *new_crc_path;  GRL_DEBUG("magnatune_source_init");  source->priv = GRL_MAGNATUNE_GET_PRIVATE(source);  source->priv->db = NULL;  path = g_build_filename(g_get_user_data_dir(), "grilo-plugins", NULL);  db_path = g_build_filename(path, GRL_SQL_DB, NULL);  crc_path = g_build_filename(path, GRL_SQL_CRC, NULL);  new_db_path = g_build_filename(path, GRL_SQL_NEW_DB, NULL);  new_crc_path = g_build_filename(path, GRL_SQL_NEW_CRC, NULL);  if(!g_file_test(path, G_FILE_TEST_IS_DIR)) {    g_mkdir_with_parents(path, 0775);  }  if (g_file_test(db_path, G_FILE_TEST_EXISTS) == TRUE) {    if (g_file_test(new_db_path, G_FILE_TEST_EXISTS) == TRUE        && g_rename(new_db_path, db_path) == 0) {        GRL_DEBUG("New database in use.");    }    if (g_file_test(new_crc_path, G_FILE_TEST_EXISTS) == TRUE        && g_rename(new_crc_path, crc_path) == 0) {        GRL_DEBUG("New crc file in use.");    }    GRL_DEBUG("Opening database connection.");    ret = sqlite3_open(db_path, &source->priv->db);    if (ret != SQLITE_OK) {      GRL_WARNING("Failed to open database '%s': %s",                  db_path,                  sqlite3_errmsg(source->priv->db));      sqlite3_close(source->priv->db);      source->priv->db = NULL;    }  } else {    GRL_DEBUG("No database was found. Download when user interact.");  }  g_free(new_crc_path);  g_free(new_db_path);  g_free(crc_path);  g_free(db_path);  g_free(path);}

static voidon_configuration_ready (GObject *source,                        GAsyncResult *result,                        gpointer user_data){  ResolveClosure *closure = (ResolveClosure *) user_data;  GrlTmdbRequest *request = GRL_TMDB_REQUEST (source);  GrlTmdbSource *self = closure->self;  GError *error = NULL;  GValue *value;  GRL_DEBUG ("Configuration request ready...");  if (!grl_tmdb_request_run_finish (GRL_TMDB_REQUEST (source),                                    result,                                    &error)) {    resolve_closure_callback (closure, error);    resolve_closure_free (closure);    /* Notify pending requests about failure */    while (!g_queue_is_empty (self->priv->pending_resolves)) {      ResolveClosure *pending_closure;      pending_closure = g_queue_pop_head (self->priv->pending_resolves);      resolve_closure_callback (pending_closure, error);      resolve_closure_free (pending_closure);    }    g_error_free (error);    return;  }  self->priv->configuration = g_object_ref (request);  remove_request (closure, request);  value = grl_tmdb_request_get (request, "$.images.base_url");  if (value != NULL) {    GRL_DEBUG ("Got TMDb configuration.");    self->priv->image_base_uri = soup_uri_new (g_value_get_string (value));    g_value_unset (value);    g_free (value);  }  g_queue_push_head (self->priv->pending_resolves, closure);  /* Flush queue. GrlNetWc will take care of throttling */  while (!g_queue_is_empty (self->priv->pending_resolves)) {    ResolveClosure *pending_closure;    pending_closure = g_queue_pop_head (self->priv->pending_resolves);    run_pending_requests (pending_closure, G_MAXINT);  }}

static voidgrl_bookmarks_source_query (GrlSource *source,                            GrlSourceQuerySpec *qs){  GRL_DEBUG ("grl_bookmarks_source_query");  GrlBookmarksSource *bookmarks_source;  OperationSpec *os;  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_QUERY_FAILED,                                 _("No database connection"));    qs->callback (qs->source, qs->operation_id, NULL, 0, qs->user_data, error);    g_error_free (error);  }  os = g_slice_new0 (OperationSpec);  os->source = qs->source;  os->operation_id = qs->operation_id;  os->count = grl_operation_options_get_count (qs->options);  os->skip = grl_operation_options_get_skip (qs->options);  os->type_filter = grl_operation_options_get_type_filter (qs->options);  os->callback = qs->callback;  os->user_data = qs->user_data;  os->error_code = GRL_CORE_ERROR_SEARCH_FAILED;  produce_bookmarks_from_query (os, qs->query);}

static gbooleanignore_mount (GMount *mount){  GFile *root;  GVolume *volume;  gboolean ret = TRUE;  root = g_mount_get_root (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);    GRL_DEBUG ("%s: Not adding mount %s as is burn or cdda", __FUNCTION__,               g_mount_get_name (mount));    return TRUE;  }  g_object_unref (root);  volume = g_mount_get_volume (mount);  if (volume == NULL)    return ret;  ret = ignore_volume (volume);  g_object_unref (volume);  return ret;}

static voidproduce_bookmarks_from_text (OperationSpec *os, const gchar *text){  GomFilter *like1, *like2, *likes, *type1, *filter;  GValue value = { 0, };  GRL_DEBUG ("produce_bookmarks_from_text");  /* WHERE (title LIKE '%text%' OR desc LIKE '%text%') AND type == BOOKMARKS_TYPE_STREAM */  like1 = substr_filter ("title", text);  like2 = substr_filter ("desc", text);  likes = gom_filter_new_or (like1, like2);  g_object_unref (like1);  g_object_unref (like2);  g_value_init (&value, G_TYPE_INT);  g_value_set_int (&value, BOOKMARKS_TYPE_STREAM);  type1 = gom_filter_new_eq (BOOKMARKS_TYPE_RESOURCE, "type", &value);  g_value_unset (&value);  filter = gom_filter_new_and (likes, type1);  g_object_unref (likes);  g_object_unref (type1);  produce_bookmarks_from_filter (os, filter);  g_object_unref (filter);}

static voidgrl_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 voidgrl_dleyna_plugin_deinit (GrlPlugin *plugin){  GRL_DEBUG (G_STRFUNC);  g_clear_object (&servers);}

static GrlDpapSource *grl_dpap_source_new (DMAPMdnsBrowserService *service){  gchar *source_desc;  gchar *source_id;  GrlDpapSource *source;  GRL_DEBUG ("grl_dpap_source_new");  source_desc = g_strdup_printf (SOURCE_DESC_TEMPLATE, service->name);  source_id = g_strdup_printf (SOURCE_ID_TEMPLATE, service->name);  source = g_object_new (GRL_DPAP_SOURCE_TYPE,                         "source-id",   source_id,                         "source-name", service->name,                         "source-desc", source_desc,                         "supported-media", GRL_SUPPORTED_MEDIA_IMAGE,                         NULL);  source->priv->service = service;  g_free (source_desc);  g_free (source_id);  return source;}

static voidresolve_album_art (ResolveData         *resolve_data,                   resolution_flags_t   flags){  const gchar *artist, *album;  GCancellable *cancellable = NULL;  GFile *cache_file = NULL;  resolve_data_start_operation (resolve_data, "album-art");  artist = grl_media_audio_get_artist (GRL_MEDIA_AUDIO (resolve_data->rs->media));  album = grl_media_audio_get_album (GRL_MEDIA_AUDIO (resolve_data->rs->media));  if (!artist || !album)    goto done;  cancellable = resolve_data_ensure_cancellable (resolve_data);  media_art_get_file (artist, album, "album", &cache_file);  if (cache_file) {    /* Check whether the cache file exists. */    resolve_data_start_operation (resolve_data, "album-art");    g_file_query_info_async (cache_file, G_FILE_ATTRIBUTE_ACCESS_CAN_READ,                             G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,                             cancellable, resolve_album_art_cb, resolve_data);  } else {    GRL_DEBUG ("Found no thumbnail for artist %s and album %s", artist, album);  }done:  resolve_data_finish_operation (resolve_data, "album-art", NULL);  g_clear_object (&cache_file);}

gbooleangrl_tmdb_source_plugin_init (GrlRegistry *registry,                             GrlPlugin *plugin,                             GList *configs){  GrlConfig *config;  char *api_key;  GRL_LOG_DOMAIN_INIT (tmdb_log_domain, "tmdb");  GRL_DEBUG ("grl_tmdb_source_plugin_init");  /* Initialize i18n */  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");  if (!configs) {    GRL_INFO ("No configuration provided. Will not load plugin");    return FALSE;  }  config = GRL_CONFIG (configs->data);  api_key = grl_config_get_api_key (config);  if (!api_key) {    GRL_INFO ("Missing API Key, cannot load plugin");    return FALSE;  }  GRL_TMDB_METADATA_KEY_BACKDROP =    register_metadata_key (registry,                           "tmdb-backdrop",                           "tmdb-backdrop",                           "A list of URLs for movie backdrops");  GRL_TMDB_METADATA_KEY_POSTER =    register_metadata_key (registry,                           "tmdb-poster",                           "tmdb-poster",                           "A list of URLs for movie posters");  GRL_TMDB_METADATA_KEY_IMDB_ID =    register_metadata_key (registry,                           "tmdb-imdb-id",                           "tmdb-imdb-id",                           "ID of this movie at imdb.org");  GRL_TMDB_METADATA_KEY_TMDB_ID =    register_metadata_key (registry,                           "tmdb-id",                           "tmdb-id",                           "ID of this movie at tmdb.org");  GrlTmdbSource *source = grl_tmdb_source_new (api_key);  grl_registry_register_source (registry,                                       plugin,                                       GRL_SOURCE (source),                                       NULL);  g_free (api_key);  return TRUE;}

static voidgrl_gravatar_source_resolve (GrlSource *source,                             GrlSourceResolveSpec *rs){  gboolean artist_avatar_required = FALSE;  gboolean author_avatar_required = FALSE;  GRL_DEBUG (__FUNCTION__);  GList *iter;  /* Check that albumart is requested */  iter = rs->keys;  while (iter && (!artist_avatar_required || !author_avatar_required)) {    GrlKeyID key = GRLPOINTER_TO_KEYID (iter->data);    if (key == GRL_METADATA_KEY_ARTIST_AVATAR) {      artist_avatar_required = TRUE;    } else if (key == GRL_METADATA_KEY_AUTHOR_AVATAR) {      author_avatar_required = TRUE;    }    iter = g_list_next (iter);  }  if (artist_avatar_required) {    set_avatar (GRL_DATA (rs->media), GRL_METADATA_KEY_ARTIST);  }  if (author_avatar_required) {    set_avatar (GRL_DATA (rs->media), GRL_METADATA_KEY_AUTHOR);  }  rs->callback (source, rs->operation_id, rs->media, rs->user_data, NULL);}

/* The caller is responsible for freeing @error. */static voidresolve_data_finish_operation (ResolveData   *data,                               const gchar   *op_name,                               const GError  *error){  g_assert (data->n_pending_operations >= 1);  data->n_pending_operations--;  GRL_DEBUG ("Finishing operation %s; %u operations still pending.",             op_name, data->n_pending_operations);  if (!data->has_invoked_callback &&      (data->n_pending_operations == 0 || error != NULL)) {    GrlSourceResolveSpec *rs = data->rs;    /* All sub-operations have finished (or one has errored), so the callback     * can be invoked. */    data->has_invoked_callback = TRUE;    rs->callback (data->source, rs->operation_id, rs->media,                  rs->user_data, error);  }  /* All sub-operations have finished, so we can free the closure. */  if (data->n_pending_operations == 0) {    g_assert (data->has_invoked_callback);    g_object_unref (data->source);    g_slice_free (ResolveData, data);  }}

gbooleangrl_gravatar_source_plugin_init (GrlRegistry *registry,                                 GrlPlugin *plugin,                                 GList *configs){  GRL_LOG_DOMAIN_INIT (gravatar_log_domain, "gravatar");  GRL_DEBUG ("grl_gravatar_source_plugin_init");  /* Initialize i18n */  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");  if (!GRL_METADATA_KEY_ARTIST_AVATAR &&      !GRL_METADATA_KEY_AUTHOR_AVATAR) {    GRL_WARNING ("Unable to register /"author-avatar/" nor /"artist-avatar/"");    return FALSE;  }  GrlGravatarSource *source = grl_gravatar_source_new ();  grl_registry_register_source (registry,                                plugin,                                GRL_SOURCE (source),                                NULL);  return TRUE;}

static gbooleanignore_volume (GVolume *volume){  gboolean ret = TRUE;  char *path;  GDrive *drive;  /* Ignore drive? */  drive = g_volume_get_drive (volume);  if (drive != NULL && ignore_drive (drive)) {    g_object_unref (drive);    return TRUE;  }  g_clear_object (&drive);  path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);  if (path != NULL) {    ret = FALSE;    g_free (path);  } else {    GRL_DEBUG ("%s: Not adding volume %s as it has no identifier", __FUNCTION__,               g_volume_get_name (volume));  }  return ret;}

static voidtracker_evt_preupdate_sources_cb (GObject              *object,                                  GAsyncResult         *result,                                  tracker_evt_update_t *evt){  GError *error = NULL;  GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);  evt->cursor = tracker_sparql_connection_query_finish (grl_tracker_connection,                                                        result, &error);  if (error != NULL) {    GRL_WARNING ("/tCannot handle datasource request : %s", error->message);    g_error_free (error);    tracker_evt_update_items (evt);    tracker_evt_update_orphans (evt);    return;  }  tracker_sparql_cursor_next_async (evt->cursor, NULL,                                    (GAsyncReadyCallback) tracker_evt_preupdate_sources_item_cb,                                    (gpointer) evt);}

static voidresolve_image (ResolveData         *resolve_data,               resolution_flags_t   flags){  GFile *file;  GCancellable *cancellable;  GRL_DEBUG ("resolve_image");  resolve_data_start_operation (resolve_data, "image");  if (flags & FLAG_THUMBNAIL) {    const gchar *attributes;    file = g_file_new_for_uri (grl_media_get_url (resolve_data->rs->media));    cancellable = resolve_data_ensure_cancellable (resolve_data);#if GLIB_CHECK_VERSION (2, 39, 0)    attributes = G_FILE_ATTRIBUTE_THUMBNAIL_PATH "," /                 G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID;#else    attributes = G_FILE_ATTRIBUTE_THUMBNAIL_PATH;#endif    g_file_query_info_async (file, attributes,                             G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, cancellable,                             (GAsyncReadyCallback)got_file_info, resolve_data);    g_object_unref (file);  } else {    resolve_data_finish_operation (resolve_data, "image", NULL);  }}

static voidgrl_bookmarks_source_init (GrlBookmarksSource *source){  GError *error = NULL;  gchar *path;  gchar *db_path;  GList *object_types;  source->priv = GRL_BOOKMARKS_GET_PRIVATE (source);  path = g_build_filename (g_get_user_data_dir (), "grilo-plugins", NULL);  if (!g_file_test (path, G_FILE_TEST_IS_DIR)) {    g_mkdir_with_parents (path, 0775);  }  GRL_DEBUG ("Opening database connection...");  db_path = g_build_filename (path, GRL_SQL_DB, NULL);  g_free (path);  source->priv->adapter = gom_adapter_new ();  if (!gom_adapter_open_sync (source->priv->adapter, db_path, &error)) {    GRL_WARNING ("Could not open database '%s': %s", db_path, error->message);    g_error_free (error);    g_free (db_path);    return;  }  g_free (db_path);  source->priv->repository = gom_repository_new (source->priv->adapter);  object_types = g_list_prepend(NULL, GINT_TO_POINTER(BOOKMARKS_TYPE_RESOURCE));  gom_repository_automatic_migrate_async (source->priv->repository, 2, object_types, migrate_cb, source);}

static GrlVimeoSource *grl_vimeo_source_new (void){  GIcon *icon;  GFile *file;  GrlVimeoSource *source;  const char *tags[] = {    "net:internet",    NULL  };  GRL_DEBUG ("grl_vimeo_source_new");  file = g_file_new_for_uri ("resource:///org/gnome/grilo/plugins/vimeo/channel-vimeo.svg");  icon = g_file_icon_new (file);  g_object_unref (file);  source = g_object_new (GRL_VIMEO_SOURCE_TYPE,                         "source-id", SOURCE_ID,                         "source-name", SOURCE_NAME,                         "source-desc", SOURCE_DESC,                         "supported-media", GRL_SUPPORTED_MEDIA_VIDEO,                         "source-icon", icon,                         "source-tags", tags,                         NULL);  g_object_unref (icon);  return source;}

static voidtracker_evt_update_source_add (tracker_evt_update_t *evt,                               const gchar *id,                               const gchar *source_name){  GrlTrackerSource *source;  GrlTrackerSourcePriv *priv;  source = g_hash_table_lookup (grl_tracker_source_sources_modified, id);  if (!source) {    source = g_object_new (GRL_TRACKER_SOURCE_TYPE,			   "source-id", id,			   "source-name", source_name,			   "source-desc", GRL_TRACKER_SOURCE_DESC,			   "tracker-connection", grl_tracker_connection,                           "tracker-datasource", id,			   NULL);    g_hash_table_insert (grl_tracker_source_sources_modified,                         (gpointer) grl_tracker_source_get_tracker_source (source),                        source);  }  priv = GRL_TRACKER_SOURCE_GET_PRIVATE (source);  priv->state = GRL_TRACKER_SOURCE_STATE_INSERTING;  priv->notification_ref++;  evt->new_sources = g_list_append (evt->new_sources, source);  GRL_DEBUG ("Preadd source p=%p name=%s id=%s count=%u",             source, source_name, id, priv->notification_ref);}

/* grl.lua.json.string_to_table * * @json_str: (string) A Json object as a string. * * @return: All json content as a table. */static gintgrl_json_parse_string (lua_State *L){  JsonParser *parser = NULL;  JsonReader *reader = NULL;  const gchar *json_str = NULL;  GError *err = NULL;  luaL_argcheck (L, lua_isstring (L, 1), 1, "json string expected");  json_str = lua_tostring (L, 1);  parser = json_parser_new ();  if (!json_parser_load_from_data (parser, json_str, -1, &err)) {    GRL_DEBUG ("Can't parse json string: '%s'", err->message);    g_error_free (err);    g_object_unref (parser);    return 0;  }  reader = json_reader_new (json_parser_get_root (parser));  /* The return of recursive function will be a table with all   * json content in it */  lua_pushnil (L);  build_table_from_json_reader (L, reader);  g_object_unref (reader);  g_object_unref (parser);  return 1;}

static voidcache_down (GrlNetWc *self){  GFile *cache_dir_file;  GrlNetWcPrivate *priv = self->priv;  SoupSessionFeature *cache = soup_session_get_feature (priv->session, SOUP_TYPE_CACHE);  gchar *cache_dir;  GRL_DEBUG ("cache down");  if (!cache) {    return;  }  soup_cache_clear (SOUP_CACHE (cache));  g_object_get (cache, "cache-dir", &cache_dir, NULL);  cache_dir_file = g_file_new_for_path (cache_dir);  g_free (cache_dir);  g_file_delete (cache_dir_file, NULL, NULL);  g_object_unref (G_OBJECT (cache_dir_file));  soup_session_remove_feature (priv->session, cache);}

static voidcache_up (GrlNetWc *self){  SoupCache *cache;  GrlNetWcPrivate *priv = self->priv;  gchar *dir;  GRL_DEBUG ("cache up");  dir = g_dir_make_tmp ("grilo-plugin-cache-XXXXXX", NULL);  if (!dir)    return;  cache = soup_cache_new (dir, SOUP_CACHE_SINGLE_USER);  g_free (dir);  soup_session_add_feature (priv->session,                            SOUP_SESSION_FEATURE (cache));  if (priv->cache_size) {    soup_cache_set_max_size (cache, priv->cache_size * 1024 * 1024);  }  g_object_unref (cache);}

static voidextract_gibest_hash (GTask        *task,                     gpointer      source_object,                     gpointer      task_data,                     GCancellable *cancellable){  GFile *file = source_object;  guint64 buffer[2][CHUNK_N_BYTES/8];  GInputStream *stream = NULL;  gssize n_bytes, file_size;  GError *error = NULL;  guint64 hash = 0;  gint i;  char *str;  ResolveData *resolve_data = task_data;  GrlLocalMetadataSourcePriv *priv;  priv = GRL_LOCAL_METADATA_SOURCE_GET_PRIVATE (resolve_data->source);  stream = G_INPUT_STREAM (g_file_read (file, cancellable, &error));  if (stream == NULL)    goto fail;  /* Extract start/end chunks of the file */  n_bytes = g_input_stream_read (stream, buffer[0], CHUNK_N_BYTES, cancellable, &error);  if (n_bytes == -1)    goto fail;  if (!g_seekable_seek (G_SEEKABLE (stream), -CHUNK_N_BYTES, G_SEEK_END, cancellable, &error))    goto fail;  n_bytes = g_input_stream_read (stream, buffer[1], CHUNK_N_BYTES, cancellable, &error);  if (n_bytes == -1)    goto fail;  for (i = 0; i < G_N_ELEMENTS (buffer[0]); i++)    hash += buffer[0][i] + buffer[1][i];  file_size = g_seekable_tell (G_SEEKABLE (stream));  if (file_size < CHUNK_N_BYTES)    goto fail;  /* Include file size */  hash += file_size;  g_object_unref (stream);  str = g_strdup_printf ("%" G_GINT64_FORMAT, hash);  grl_data_set_string (GRL_DATA (resolve_data->rs->media), priv->hash_keyid, str);  g_free (str);  g_task_return_boolean (task, TRUE);  return;fail:  GRL_DEBUG ("Could not get file hash: %s/n", error ? error->message : "Unknown error");  g_task_return_error (task, error);  g_clear_object (&stream);}