static gboolean
get_video_play_url_cb (GVimeoVideoURLData *url_data)
{
gchar *url = NULL;
TotemPlParser *parser;
TotemPlParserResult res;
parser = totem_pl_parser_new ();
g_signal_connect (parser, "entry-parsed",
G_CALLBACK (entry_parsed_cb), &url);
res = totem_pl_parser_parse (parser,
url_data->vimeo_url,
FALSE);
if (res != TOTEM_PL_PARSER_RESULT_SUCCESS)
url_data->callback (NULL, url_data->user_data);
else
url_data->callback (url, url_data->user_data);
g_clear_object (&parser);
g_object_unref (url_data->vimeo);
g_free (url_data->vimeo_url);
g_slice_free (GVimeoVideoURLData, url_data);
return FALSE;
}
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);
}
void
rb_iradio_source_add_from_playlist (RBIRadioSource *source,
const char *uri)
{
TotemPlParser *parser = totem_pl_parser_new ();
char *real_uri;
real_uri = guess_uri_scheme (uri);
if (real_uri)
uri = real_uri;
g_signal_connect_object (parser, "entry-parsed",
G_CALLBACK (handle_playlist_entry_cb),
source, 0);
g_object_set (parser, "recurse", FALSE, NULL);
switch (totem_pl_parser_parse (parser, uri, FALSE)) {
case TOTEM_PL_PARSER_RESULT_UNHANDLED:
case TOTEM_PL_PARSER_RESULT_IGNORED:
/* maybe it's the actual stream URL, then */
rb_iradio_source_add_station (source, uri, NULL, NULL);
break;
default:
case TOTEM_PL_PARSER_RESULT_SUCCESS:
case TOTEM_PL_PARSER_RESULT_ERROR:
break;
}
g_object_unref (parser);
g_free (real_uri);
}
/**
* rb_playlist_source_save_playlist:
* @source: a #RBPlaylistSource
* @uri: destination URI
* @export_type: format to save in
*
* Saves the playlist to an external file in a standard
* format (M3U, PLS, or XSPF).
*/
void
rb_playlist_source_save_playlist (RBPlaylistSource *source,
const char *uri,
RBPlaylistExportType export_type)
{
TotemPlParser *pl;
GError *error = NULL;
char *name;
gint totem_format;
#if TOTEM_PL_PARSER_CHECK_VERSION(2,29,1)
TotemPlPlaylist *playlist;
GFile *file;
#endif
g_return_if_fail (RB_IS_PLAYLIST_SOURCE (source));
rb_debug ("saving playlist");
pl = totem_pl_parser_new ();
g_object_get (source, "name", &name, NULL);
switch (export_type) {
case RB_PLAYLIST_EXPORT_TYPE_XSPF:
totem_format = TOTEM_PL_PARSER_XSPF;
break;
case RB_PLAYLIST_EXPORT_TYPE_M3U:
totem_format = TOTEM_PL_PARSER_M3U;
break;
case RB_PLAYLIST_EXPORT_TYPE_PLS:
default:
totem_format = TOTEM_PL_PARSER_PLS;
break;
}
#if TOTEM_PL_PARSER_CHECK_VERSION(2,29,1)
file = g_file_new_for_uri (uri);
playlist = totem_pl_playlist_new ();
gtk_tree_model_foreach (GTK_TREE_MODEL (source->priv->model),
(GtkTreeModelForeachFunc)playlist_iter_foreach,
playlist);
totem_pl_parser_save (pl, playlist, file, name, totem_format, &error);
g_object_unref (playlist);
g_object_unref (file);
#else
totem_pl_parser_write_with_title (pl, GTK_TREE_MODEL (source->priv->model),
playlist_iter_func, uri, name,
totem_format,
NULL, &error);
#endif
g_object_unref (pl);
g_free (name);
if (error != NULL) {
rb_error_dialog (NULL, _("Couldn't save playlist"),
"%s", error->message);
g_error_free (error);
}
}
G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *info)
{
TotemPlParser *pl;
TrackerSparqlBuilder *metadata;
PlaylistMetadata data;
GFile *file;
gchar *uri;
pl = totem_pl_parser_new ();
file = tracker_extract_info_get_file (info);
uri = g_file_get_uri (file);
metadata = tracker_extract_info_get_metadata_builder (info);
data.track_counter = PLAYLIST_DEFAULT_NO_TRACKS;
data.total_time = PLAYLIST_DEFAULT_DURATION;
data.title = NULL;
data.metadata = metadata;
g_object_set (pl, "recurse", FALSE, "disable-unsafe", TRUE, NULL);
g_signal_connect (G_OBJECT (pl), "playlist-started", G_CALLBACK (playlist_started), &data);
g_signal_connect (G_OBJECT (pl), "entry-parsed", G_CALLBACK (entry_parsed), &data);
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nmm:Playlist");
tracker_sparql_builder_object (metadata, "nfo:MediaList");
if (totem_pl_parser_parse (pl, uri, FALSE) == TOTEM_PL_PARSER_RESULT_SUCCESS) {
if (data.title != NULL) {
g_message ("Playlist title:'%s'", data.title);
tracker_sparql_builder_predicate (metadata, "nie:title");
tracker_sparql_builder_object_unvalidated (metadata, data.title);
g_free (data.title);
} else {
g_message ("Playlist has no title, attempting to get one from filename");
tracker_guarantee_title_from_file (metadata, "nie:title", NULL, uri, NULL);
}
if (data.total_time > 0) {
tracker_sparql_builder_predicate (metadata, "nfo:listDuration");
tracker_sparql_builder_object_int64 (metadata, data.total_time);
}
if (data.track_counter > 0) {
tracker_sparql_builder_predicate (metadata, "nfo:entryCounter");
tracker_sparql_builder_object_int64 (metadata, data.track_counter);
}
} else {
g_warning ("Playlist could not be parsed, no error given");
}
g_object_unref (pl);
g_free (uri);
return TRUE;
}
gboolean
brasero_project_open_audio_playlist_project (const gchar *uri,
BraseroBurnSession *session,
gboolean warn_user)
{
TotemPlParser *parser;
TotemPlParserResult result;
GFile *file;
char *_uri;
file = g_file_new_for_commandline_arg (uri);
_uri = g_file_get_uri (file);
g_object_unref (file);
parser = totem_pl_parser_new ();
g_object_set (parser,
"recurse", FALSE,
"disable-unsafe", TRUE,
NULL);
g_signal_connect (parser,
"playlist-started",
G_CALLBACK (brasero_project_playlist_playlist_started),
session);
g_signal_connect (parser,
"entry-parsed",
G_CALLBACK (brasero_project_playlist_entry_parsed),
session);
result = totem_pl_parser_parse (parser, _uri, FALSE);
if (result != TOTEM_PL_PARSER_RESULT_SUCCESS) {
if (warn_user)
brasero_project_invalid_project_dialog (_("It does not seem to be a valid Brasero project"));
}
g_free (_uri);
g_object_unref (parser);
return (result == TOTEM_PL_PARSER_RESULT_SUCCESS);
}
static char *
get_special_url (GFile *file)
{
char *path, *orig_uri, *uri, *mime_type;
TotemPlParser *parser;
TotemPlParserResult res;
path = g_file_get_path (file);
mime_type = g_content_type_guess (path, NULL, 0, NULL);
g_free (path);
if (g_strcmp0 (mime_type, "application/x-cd-image") != 0) {
g_free (mime_type);
return NULL;
}
g_free (mime_type);
uri = NULL;
orig_uri = g_file_get_uri (file);
parser = totem_pl_parser_new ();
g_signal_connect (parser, "entry-parsed",
G_CALLBACK (entry_parsed_cb), &uri);
res = totem_pl_parser_parse (parser, orig_uri, FALSE);
g_free (orig_uri);
g_object_unref (parser);
if (res == TOTEM_PL_PARSER_RESULT_SUCCESS)
return uri;
g_free (uri);
return NULL;
}
static void
grl_optical_media_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GList *drives;
GList *volumes;
GList *l;
GrlOpticalMediaSourcePrivate *priv = GRL_OPTICAL_MEDIA_SOURCE (source)->priv;
BrowseData *data;
GList *media_list;
GRL_DEBUG ("%s", __FUNCTION__);
media_list = NULL;
/* Get the drives */
drives = g_volume_monitor_get_connected_drives (priv->monitor);
for (l = drives; l != NULL; l = l->next) {
GDrive *drive = l->data;
media_list = add_drive (media_list, drive, GRL_OPTICAL_MEDIA_SOURCE (source));
g_object_unref (drive);
}
g_list_free (drives);
/* Look for mounted ISO images */
volumes = g_volume_monitor_get_volumes (priv->monitor);
for (l = volumes; l != NULL; l = l->next) {
GVolume *volume = l->data;
char *path;
path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (path != NULL && g_str_has_prefix (path, "/dev/loop"))
media_list = add_volume (media_list, volume, NULL, GRL_OPTICAL_MEDIA_SOURCE (source));
g_free (path);
g_object_unref (volume);
}
g_list_free (volumes);
/* Got nothing? */
if (media_list == NULL) {
/* Tell the caller we're done */
bs->callback (bs->source,
bs->operation_id,
NULL,
0,
bs->user_data,
NULL);
return;
}
media_list = g_list_reverse (media_list);
/* And go to resolve all those devices */
data = g_new0 (BrowseData, 1);
data->source = source;
data->bs = bs;
data->media_list = media_list;
data->cancellable = g_cancellable_new ();
grl_operation_set_data (bs->operation_id, data->cancellable);
data->parser = totem_pl_parser_new ();
g_object_set (data->parser, "recurse", FALSE, NULL);
g_signal_connect (G_OBJECT (data->parser), "entry-parsed",
G_CALLBACK (entry_parsed_cb), data);
resolve_disc_urls (data);
}
static gboolean
load_playlist (RBGenericPlayerPlaylistSource *source)
{
RBGenericPlayerPlaylistSourcePrivate *priv = GET_PRIVATE (source);
TotemPlParser *parser;
gboolean result;
GFile *file;
char *name;
char *uri;
if (priv->playlist_path == NULL) {
/* this happens when we're creating a new playlist */
rb_debug ("playlist has no path; obviously can't load it");
g_object_set (source, "name", "", NULL);
return TRUE;
}
priv->loading = TRUE;
file = g_file_new_for_path (priv->playlist_path);
/* make a default name for the playlist based on the filename */
name = g_file_get_basename (file);
g_object_set (source, "name", name, NULL);
g_free (name);
parser = totem_pl_parser_new ();
if (rb_debug_matches ("totem_pl_parser_parse", "totem-pl-parser.c")) {
g_object_set (parser, "debug", TRUE, NULL);
}
rb_generic_player_source_set_supported_formats (priv->player_source, parser);
g_signal_connect (parser,
"entry-parsed", G_CALLBACK (handle_playlist_entry_cb),
source);
g_signal_connect (parser,
"playlist-started", G_CALLBACK (handle_playlist_start_cb),
source);
g_object_set (G_OBJECT (parser), "recurse", FALSE, NULL);
uri = g_file_get_uri (file);
switch (totem_pl_parser_parse_with_base (parser, uri, priv->device_root, FALSE)) {
case TOTEM_PL_PARSER_RESULT_SUCCESS:
rb_debug ("playlist parsed successfully");
result = TRUE;
break;
case TOTEM_PL_PARSER_RESULT_ERROR:
rb_debug ("playlist parser returned an error");
result = FALSE;
break;
case TOTEM_PL_PARSER_RESULT_UNHANDLED:
rb_debug ("playlist parser didn't handle the file");
result = FALSE;
break;
case TOTEM_PL_PARSER_RESULT_IGNORED:
rb_debug ("playlist parser ignored the file");
result = FALSE;
break;
default:
g_assert_not_reached ();
}
g_free (uri);
g_object_unref (file);
priv->loading = FALSE;
return result;
}
static gboolean
save_playlist (RBGenericPlayerPlaylistSource *source)
{
TotemPlParser *parser;
TotemPlParserType playlist_type;
RhythmDBQueryModel *query_model;
char *name;
char *temp_path;
GError *error = NULL;
RBGenericPlayerPlaylistSourcePrivate *priv = GET_PRIVATE (source);
GFile *file;
gboolean result;
SavePlaylistData data;
priv->save_playlist_id = 0;
playlist_type = rb_generic_player_source_get_playlist_format (priv->player_source);
g_object_get (source,
"name", &name,
"base-query-model", &query_model,
NULL);
/* if we don't already have a name for this playlist, make one now */
if (priv->playlist_path == NULL) {
char *playlist_dir;
char *mount_uri;
char *filename;
const char *ext;
GFile *dir;
GFile *playlist;
ext = playlist_format_extension (playlist_type);
if (name == NULL || name[0] == '\0') {
/* now what? */
filename = g_strdup_printf ("unnamed%s", ext);
} else {
filename = g_strdup_printf ("%s%s", name, ext);
}
playlist_dir = rb_generic_player_source_get_playlist_path (priv->player_source);
mount_uri = rb_generic_player_source_get_mount_path (priv->player_source);
dir = g_file_new_for_uri (mount_uri);
if (playlist_dir != NULL) {
GFile *pdir;
pdir = g_file_resolve_relative_path (dir, playlist_dir);
g_object_unref (dir);
dir = pdir;
}
playlist = g_file_resolve_relative_path (dir, filename);
priv->playlist_path = g_file_get_path (playlist);
g_free (mount_uri);
g_free (playlist_dir);
g_object_unref (dir);
}
temp_path = g_strdup_printf ("%s%06X", priv->playlist_path, g_random_int_range (0, 0xFFFFFF));
file = g_file_new_for_path (temp_path);
parser = totem_pl_parser_new ();
data.source = source;
data.playlist_type = playlist_type;
#if TOTEM_PL_PARSER_CHECK_VERSION(2,29,1)
data.playlist = totem_pl_playlist_new ();
gtk_tree_model_foreach (GTK_TREE_MODEL (query_model),
(GtkTreeModelForeachFunc) save_playlist_foreach,
&data);
if (rb_debug_matches ("totem_pl_parser_save", "totem-pl-parser.c")) {
g_object_set (parser, "debug", TRUE, NULL);
}
result = totem_pl_parser_save (parser, data.playlist, file, name, playlist_type, &error);
g_object_unref (data.playlist);
data.playlist = NULL;
#else
if (rb_debug_matches ("totem_pl_parser_write_with_title", "totem-pl-parser.c")) {
g_object_set (parser, "debug", TRUE, NULL);
}
result = totem_pl_parser_write_with_title (parser,
GTK_TREE_MODEL (query_model),
(TotemPlParserIterFunc) save_playlist_entry,
temp_path,
name,
playlist_type,
&data,
&error);
#endif
if (result == FALSE) {
/* XXX report this more usefully */
g_warning ("Playlist save failed: %s", error ? error->message : "<no error>");
} else {
GFile *dest;
dest = g_file_new_for_path (priv->playlist_path);
g_file_move (file, dest, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NO_FALLBACK_FOR_MOVE, NULL, NULL, NULL, &error);
if (error != NULL) {
/* XXX report this more usefully */
g_warning ("moving %s => %s failed: %s", temp_path, priv->playlist_path, error->message);
}
g_object_unref (dest);
}
g_clear_error (&error);
g_free (name);
g_free (temp_path);
g_object_unref (query_model);
g_object_unref (parser);
g_object_unref (file);
return FALSE;
}
static void
grl_optical_media_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GList *mounts, *l;
GrlOpticalMediaSourcePrivate *priv = GRL_OPTICAL_MEDIA_SOURCE (source)->priv;
BrowseData *data;
GList *media_list;
GRL_DEBUG ("%s", __FUNCTION__);
g_list_free_full (priv->list, g_object_unref);
media_list = NULL;
/* Look for loopback-mounted ISO images and discs */
mounts = g_volume_monitor_get_mounts (priv->monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = l->data;
if (!ignore_mount (mount)) {
GrlMedia *media;
media = create_media_from_mount (mount);
if (media)
media_list = g_list_prepend (media_list, media);
}
g_object_unref (mount);
}
g_list_free (mounts);
/* Got nothing? */
if (media_list == NULL) {
/* Tell the caller we're done */
bs->callback (bs->source,
bs->operation_id,
NULL,
0,
bs->user_data,
NULL);
return;
}
media_list = g_list_reverse (media_list);
/* And go to resolve all those devices */
data = g_new0 (BrowseData, 1);
data->source = source;
data->bs = bs;
data->media_list = media_list;
data->cancellable = g_cancellable_new ();
grl_operation_set_data (bs->operation_id, data->cancellable);
data->parser = totem_pl_parser_new ();
g_object_set (data->parser, "recurse", FALSE, NULL);
g_signal_connect (G_OBJECT (data->parser), "entry-parsed",
G_CALLBACK (entry_parsed_cb), &data->media);
resolve_disc_urls (data);
}
static gboolean
save_playlist (RBGenericPlayerPlaylistSource *source)
{
TotemPlParser *parser;
TotemPlParserType playlist_type;
RhythmDBQueryModel *query_model;
char *name;
char *temp_uri;
GError *error = NULL;
RBGenericPlayerPlaylistSourcePrivate *priv = GET_PRIVATE (source);
priv->save_playlist_id = 0;
playlist_type = rb_generic_player_source_get_playlist_format (priv->player_source);
g_object_get (source,
"name", &name,
"base-query-model", &query_model,
NULL);
/* if we don't already have a name for this playlist, make one now */
if (priv->playlist_path == NULL) {
char *playlist_dir;
char *mount_uri;
char *filename;
const char *ext;
GFile *dir;
GFile *playlist;
ext = playlist_format_extension (playlist_type);
if (name == NULL || name[0] == '\0') {
/* now what? */
filename = g_strdup_printf ("unnamed%s", ext);
} else {
filename = g_strdup_printf ("%s%s", name, ext);
}
playlist_dir = rb_generic_player_source_get_playlist_path (priv->player_source);
mount_uri = rb_generic_player_source_get_mount_path (priv->player_source);
dir = g_file_new_for_uri (mount_uri);
if (playlist_dir != NULL) {
GFile *pdir;
pdir = g_file_resolve_relative_path (dir, playlist_dir);
g_object_unref (dir);
dir = pdir;
}
playlist = g_file_resolve_relative_path (dir, filename);
priv->playlist_path = g_file_get_path (playlist);
g_free (mount_uri);
g_free (playlist_dir);
g_object_unref (dir);
}
temp_uri = g_strdup_printf ("%s%06X", priv->playlist_path, g_random_int_range (0, 0xFFFFFF));
parser = totem_pl_parser_new ();
if (rb_debug_matches ("totem_pl_parser_write_with_title", "totem-pl-parser.c")) {
g_object_set (parser, "debug", TRUE, NULL);
}
if (totem_pl_parser_write_with_title (parser,
GTK_TREE_MODEL (query_model),
(TotemPlParserIterFunc) save_playlist_entry,
temp_uri,
name,
playlist_type,
source,
&error) == FALSE) {
/* XXX report this more usefully */
g_warning ("Playlist save failed: %s", error->message);
} else {
GFile *dest;
GFile *src;
dest = g_file_new_for_path (priv->playlist_path);
src = g_file_new_for_path (temp_uri);
g_file_move (src, dest, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NO_FALLBACK_FOR_MOVE, NULL, NULL, NULL, &error);
if (error != NULL) {
/* XXX report this more usefully */
g_warning ("Replacing playlist failed: %s", error->message);
}
g_object_unref (dest);
g_object_unref (src);
}
g_clear_error (&error);
g_free (name);
g_free (temp_uri);
g_object_unref (query_model);
return FALSE;
}
gboolean
brasero_project_save_audio_project_playlist (BraseroBurnSession *session,
const gchar *uri,
BraseroProjectSave type)
{
TotemPlParserType pl_type;
TotemPlParser *parser;
TotemPlPlaylist *playlist;
TotemPlPlaylistIter pl_iter;
gboolean result;
GFile *file;
GSList *iter;
file = g_file_new_for_uri (uri);
parser = totem_pl_parser_new ();
playlist = totem_pl_playlist_new ();
/* populate playlist */
iter = brasero_burn_session_get_tracks (session);
for (; iter; iter = iter->next) {
BraseroTrackStream *track;
const gchar *title;
gchar *uri;
track = iter->data;
uri = brasero_track_stream_get_source (track, TRUE);
title = brasero_track_tag_lookup_string (BRASERO_TRACK (track), BRASERO_TRACK_STREAM_TITLE_TAG);
totem_pl_playlist_append (playlist, &pl_iter);
totem_pl_playlist_set (playlist, &pl_iter,
TOTEM_PL_PARSER_FIELD_URI, uri,
TOTEM_PL_PARSER_FIELD_TITLE, title,
NULL);
g_free (uri);
}
switch (type) {
case BRASERO_PROJECT_SAVE_PLAYLIST_M3U:
pl_type = TOTEM_PL_PARSER_M3U;
break;
case BRASERO_PROJECT_SAVE_PLAYLIST_XSPF:
pl_type = TOTEM_PL_PARSER_XSPF;
break;
case BRASERO_PROJECT_SAVE_PLAYLIST_IRIVER_PLA:
pl_type = TOTEM_PL_PARSER_IRIVER_PLA;
break;
case BRASERO_PROJECT_SAVE_PLAYLIST_PLS:
default:
pl_type = TOTEM_PL_PARSER_PLS;
break;
}
result = totem_pl_parser_save (parser, playlist, file,
brasero_burn_session_get_label (session),
pl_type, NULL);
g_object_unref (playlist);
g_object_unref (parser);
g_object_unref (file);
return result;
}
gboolean
rb_podcast_parse_load_feed (RBPodcastChannel *data,
const char *file_name,
gboolean existing_feed,
GError **error)
{
GFile *file;
GFileInfo *fileinfo;
TotemPlParser *plparser;
data->url = g_strdup (file_name);
/* if the URL has a .rss, .xml or .atom extension (before the query string),
* don't bother checking the MIME type.
*/
if (rb_uri_could_be_podcast (file_name, &data->is_opml) || existing_feed) {
rb_debug ("not checking mime type for %s (should be %s file)", file_name,
data->is_opml ? "OPML" : "Podcast");
} else {
GError *ferror = NULL;
char *content_type;
rb_debug ("checking mime type for %s", file_name);
file = g_file_new_for_uri (file_name);
fileinfo = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0, NULL, &ferror);
if (ferror != NULL) {
g_set_error (error,
RB_PODCAST_PARSE_ERROR,
RB_PODCAST_PARSE_ERROR_FILE_INFO,
_("Unable to check file type: %s"),
ferror->message);
g_object_unref (file);
g_clear_error (&ferror);
return FALSE;
}
content_type = g_file_info_get_attribute_as_string (fileinfo, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
g_object_unref (file);
g_object_unref (fileinfo);
if (content_type != NULL
&& strstr (content_type, "html") == NULL
&& strstr (content_type, "xml") == NULL
&& strstr (content_type, "rss") == NULL
&& strstr (content_type, "opml") == NULL) {
g_set_error (error,
RB_PODCAST_PARSE_ERROR,
RB_PODCAST_PARSE_ERROR_MIME_TYPE,
_("Unexpected file type: %s"),
content_type);
g_free (content_type);
return FALSE;
} else if (content_type != NULL
&& strstr (content_type, "opml") != NULL) {
data->is_opml = TRUE;
}
g_free (content_type);
}
plparser = totem_pl_parser_new ();
g_object_set (plparser, "recurse", FALSE, "force", TRUE, NULL);
g_signal_connect (G_OBJECT (plparser), "entry-parsed", G_CALLBACK (entry_parsed), data);
g_signal_connect (G_OBJECT (plparser), "playlist-started", G_CALLBACK (playlist_started), data);
g_signal_connect (G_OBJECT (plparser), "playlist-ended", G_CALLBACK (playlist_ended), data);
if (totem_pl_parser_parse (plparser, file_name, FALSE) != TOTEM_PL_PARSER_RESULT_SUCCESS) {
rb_debug ("Parsing %s as a Podcast failed", file_name);
g_set_error (error,
RB_PODCAST_PARSE_ERROR,
RB_PODCAST_PARSE_ERROR_XML_PARSE,
_("Unable to parse the feed contents"));
g_object_unref (plparser);
return FALSE;
}
g_object_unref (plparser);
/* treat empty feeds, or feeds that don't contain any downloadable items, as
* an error.
*/
if (data->posts == NULL) {
rb_debug ("Parsing %s as a podcast succeeded, but the feed contains no downloadable items", file_name);
g_set_error (error,
RB_PODCAST_PARSE_ERROR,
RB_PODCAST_PARSE_ERROR_NO_ITEMS,
_("The feed does not contain any downloadable items"));
return FALSE;
}
rb_debug ("Parsing %s as a Podcast succeeded", file_name);
return TRUE;
}
